eschnett/cactusamrex - Change YXQEXAD63KY6PZRPJGGIXZ44L7O3BU5CO7JFBRTFXGAUROGN76ZQC

Z4c: Disable always-inline when building in debug mode

Created by Erik Schnetter on April 3, 2020

YXQEXAD63KY6PZRPJGGIXZ44L7O3BU5CO7JFBRTFXGAUROGN76ZQC

Dependencies

In channels

master

main

Change contents

Replacement in Z4c/src/derivs.hxx at line 29 [2.60922]

B:BD[2.61433] → [2.61433:61588]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T deriv1d(const T *restrict const var,
                                              const ptrdiff_t di, const T dx) {

[2.61433]

[2.61588]

inline Z4C_INLINE T deriv1d(const T *restrict const var, const ptrdiff_t di,
                            const T dx) {

Replacement in Z4c/src/derivs.hxx at line 44 [2.60922]

B:BD[2.61861] → [2.61861:62009]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T
deriv1d_upwind(const T *restrict const var, const ptrdiff_t di, const bool sign,
               const T dx) {

[2.61861]

[2.62009]

inline Z4C_INLINE T deriv1d_upwind(const T *restrict const var,
                                   const ptrdiff_t di, const bool sign,
                                   const T dx) {

Replacement in Z4c/src/derivs.hxx at line 88 [2.60922]

B:BD[2.63206] → [2.63206:63413]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T deriv2_1d(const T *restrict const var,
                                                const ptrdiff_t di,
                                                const T dx) {

[2.63206]

[2.63413]

inline Z4C_INLINE T deriv2_1d(const T *restrict const var, const ptrdiff_t di,
                              const T dx) {

Replacement in Z4c/src/derivs.hxx at line 106 [2.60922]

B:BD[2.63771] → [2.63771:64058]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T deriv2_2d(const T *restrict const var,
                                                const ptrdiff_t di,
                                                const ptrdiff_t dj, const T dx,
                                                const T dy) {

[2.63771]

[2.64058]

inline Z4C_INLINE T deriv2_2d(const T *restrict const var, const ptrdiff_t di,
                              const ptrdiff_t dj, const T dx, const T dy) {

Replacement in Z4c/src/derivs.hxx at line 116 [2.60922]

B:BD[2.64295] → [2.64295:64511]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T deriv1d_diss(const T *restrict const var,
                                                   const ptrdiff_t di,
                                                   const T dx) {

[2.64295]

[2.64511]

inline Z4C_INLINE T deriv1d_diss(const T *restrict const var,
                                 const ptrdiff_t di, const T dx) {

Replacement in Z4c/src/derivs.hxx at line 138 [2.60922]

B:BD[2.65032] → [2.65032:65249]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T deriv(const GF3D<const T, 0, 0, 0> &gf_,
                                            const vect<int, dim> &I,
                                            const vec3<T, UP> &dx) {

[2.65032]

[2.65249]

inline Z4C_INLINE T deriv(const GF3D<const T, 0, 0, 0> &gf_,
                          const vect<int, dim> &I, const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 146 [2.60922]

B:BD[2.65408] → [2.65408:65574]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T
deriv_upwind(const GF3D<const T, 0, 0, 0> &gf_, const vect<int, dim> &I,
             const bool sign, const vec3<T, UP> &dx) {

[2.65408]

[2.65574]

inline Z4C_INLINE T deriv_upwind(const GF3D<const T, 0, 0, 0> &gf_,
                                 const vect<int, dim> &I, const bool sign,
                                 const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 155 [2.60922]

B:BD[2.65757] → [2.65757:65824]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE enable_if_t<(dir1 == dir2), T>

[2.65757]

[2.65824]

inline Z4C_INLINE enable_if_t<(dir1 == dir2), T>

Replacement in Z4c/src/derivs.hxx at line 164 [2.60922]

B:BD[2.66097] → [2.66097:66164]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE enable_if_t<(dir1 != dir2), T>

[2.66097]

[2.66164]

inline Z4C_INLINE enable_if_t<(dir1 != dir2), T>

Replacement in Z4c/src/derivs.hxx at line 174 [2.60922]

B:BD[2.66485] → [2.66485:66630]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T
deriv_diss(const GF3D<const T, 0, 0, 0> &gf_, const vect<int, dim> &I,
           const vec3<T, UP> &dx) {

[2.66485]

[2.66630]

inline Z4C_INLINE T deriv_diss(const GF3D<const T, 0, 0, 0> &gf_,
                               const vect<int, dim> &I, const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 184 [2.60922]

B:BD[2.66867] → [2.66867:67012]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, DN>
deriv(const GF3D<const T, 0, 0, 0> &gf_, const vect<int, dim> &I,
      const vec3<T, UP> &dx) {

[2.66867]

[2.67012]

inline Z4C_INLINE vec3<T, DN> deriv(const GF3D<const T, 0, 0, 0> &gf_,
                                    const vect<int, dim> &I,
                                    const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 195 [2.60922]
B:BD[2.67137] → [2.67137:67185]
```
inline CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, DN>
```
[2.67137]
[2.67185]
```
inline Z4C_INLINE vec3<T, DN>
```

Replacement in Z4c/src/derivs.hxx at line 206 [2.60922]

B:BD[2.67517] → [2.67517:67668]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, DN, DN>
deriv2(const GF3D<const T, 0, 0, 0> &gf_, const vect<int, dim> &I,
       const vec3<T, UP> &dx) {

[2.67517]

[2.67668]

inline Z4C_INLINE mat3<T, DN, DN> deriv2(const GF3D<const T, 0, 0, 0> &gf_,
                                         const vect<int, dim> &I,
                                         const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 217 [2.60922]

B:BD[2.67883] → [2.67883:68097]

inline CCTK_ATTRIBUTE_ALWAYS_INLINE T diss(const GF3D<const T, 0, 0, 0> &gf_,
                                           const vect<int, dim> &I,
                                           const vec3<T, UP> &dx) {

[2.67883]

[2.68097]

inline Z4C_INLINE T diss(const GF3D<const T, 0, 0, 0> &gf_,
                         const vect<int, dim> &I, const vec3<T, UP> &dx) {

Replacement in Z4c/src/derivs.hxx at line 238 [2.60922]

B:BD[2.68781] → [2.68781:69067]

  loop_int<0, 0, 0>(cctkGH,
                    [&](const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE {
                      const auto dval = deriv(gf_, p.I, dx);
                      for (int a = 0; a < 3; ++a)
                        dgf_(a)(p.I) = dval(a);
                    });

[2.68781]

[2.69067]

  loop_int<0, 0, 0>(cctkGH, [&](const PointDesc &p) Z4C_INLINE {
    const auto dval = deriv(gf_, p.I, dx);
    for (int a = 0; a < 3; ++a)
      dgf_(a)(p.I) = dval(a);
  });

Replacement in Z4c/src/derivs.hxx at line 255 [2.60922]

B:BD[2.69433] → [2.69433:69942]

  loop_int<0, 0, 0>(cctkGH,
                    [&](const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE {
                      const auto dval = deriv(gf_, p.I, dx);
                      for (int a = 0; a < 3; ++a)
                        dgf_(a)(p.I) = dval(a);
                      const auto ddval = deriv2(gf_, p.I, dx);
                      for (int a = 0; a < 3; ++a)
                        for (int b = a; b < 3; ++b)
                          ddgf_(a, b)(p.I) = ddval(a, b);
                    });

[2.69433]

[2.69942]

  loop_int<0, 0, 0>(cctkGH, [&](const PointDesc &p) Z4C_INLINE {
    const auto dval = deriv(gf_, p.I, dx);
    for (int a = 0; a < 3; ++a)
      dgf_(a)(p.I) = dval(a);
    const auto ddval = deriv2(gf_, p.I, dx);
    for (int a = 0; a < 3; ++a)
      for (int b = a; b < 3; ++b)
        ddgf_(a, b)(p.I) = ddval(a, b);
  });

Replacement in Z4c/src/derivs.hxx at line 316 [2.60922]

B:BD[2.71868] → [2.71868:72186]

  loop_int<0, 0, 0>(
      cctkGH, [&](const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE {
        const vec3<CCTK_REAL, UP> betaG = gf_betaG_(p.I);
        const vec3<CCTK_REAL, DN> dgf_upwind(deriv_upwind(gf_, p.I, betaG, dx));
        gf_rhs_(p.I) += sum1([&](int x) { return betaG(x) * dgf_upwind(x); });
      });

[2.71868]

[2.72186]

  loop_int<0, 0, 0>(cctkGH, [&](const PointDesc &p) Z4C_INLINE {
    const vec3<CCTK_REAL, UP> betaG = gf_betaG_(p.I);
    const vec3<CCTK_REAL, DN> dgf_upwind(deriv_upwind(gf_, p.I, betaG, dx));
    gf_rhs_(p.I) += sum1([&](int x) { return betaG(x) * dgf_upwind(x); });
  });

Replacement in Z4c/src/derivs.hxx at line 335 [2.60922]

B:BD[2.72599] → [2.72599:72794]

  loop_int<0, 0, 0>(cctkGH,
                    [&](const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE {
                      gf_rhs_(p.I) += epsdiss * diss(gf_, p.I, dx);
                    });

[2.72599]

[2.72794]

  loop_int<0, 0, 0>(cctkGH, [&](const PointDesc &p) Z4C_INLINE {
    gf_rhs_(p.I) += epsdiss * diss(gf_, p.I, dx);
  });

Replacement in Z4c/src/enforce.cxx at line 39 [3.22673]

B:BD[3.23693] → [2.72847:72937]

  loop_all<0, 0, 0>(
      cctkGH, [&](const PointDesc &p) CCTK_ATTRIBUTE_ALWAYS_INLINE {

[3.23693]

[2.72937]

  loop_all<0, 0, 0>(cctkGH, [&](const PointDesc &p) Z4C_INLINE {

Replacement in Z4c/src/physics.hxx at line 9 [3.31007]

B:BD[3.31111] → [2.75511:75576]

CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr mat3<vec3<T, DN>, UP, UP>

[3.31111]

[4.5487]

Z4C_INLINE constexpr mat3<vec3<T, DN>, UP, UP>

Replacement in Z4c/src/physics.hxx at line 18 [3.31007]

B:BD[3.31495] → [2.75577:75863]

  return mat3<vec3<T, DN>, UP, UP>(
      [&](int a, int b) CCTK_ATTRIBUTE_ALWAYS_INLINE {
        return vec3<T, DN>([&](int c) CCTK_ATTRIBUTE_ALWAYS_INLINE {
          return sum2(
              [&](int x, int y) { return -gu(a, x) * gu(b, y) * dg(x, y)(c); });
        });
      });

[3.31495]

[3.31806]

  return mat3<vec3<T, DN>, UP, UP>([&](int a, int b) Z4C_INLINE {
    return vec3<T, DN>([&](int c) Z4C_INLINE {
      return sum2(
          [&](int x, int y) { return -gu(a, x) * gu(b, y) * dg(x, y)(c); });
    });
  });

Replacement in Z4c/src/physics.hxx at line 27 [3.31007]

B:BD[3.31831] → [2.75864:75929]

CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr mat3<vec3<T, DN>, UP, UP>

[3.31831]

[4.5724]

Z4C_INLINE constexpr mat3<vec3<T, DN>, UP, UP>

Replacement in Z4c/src/physics.hxx at line 32 [3.31007]

B:BD[3.32073] → [2.75930:76359]

  return mat3<vec3<T, DN>, UP, UP>(
      [&](int a, int b) CCTK_ATTRIBUTE_ALWAYS_INLINE {
        return vec3<T, DN>([&](int c) CCTK_ATTRIBUTE_ALWAYS_INLINE {
          return sum2([&](int x, int y) CCTK_ATTRIBUTE_ALWAYS_INLINE {
            return dgu(a, x)(c) * gu(b, y) * A(x, y)   //
                   + gu(a, x) * dgu(b, y)(c) * A(x, y) //
                   + gu(a, x) * gu(b, y) * dA(x, y)(c);
          });
        });

[3.32073]

[5.14315]

  return mat3<vec3<T, DN>, UP, UP>([&](int a, int b) Z4C_INLINE {
    return vec3<T, DN>([&](int c) Z4C_INLINE {
      return sum2([&](int x, int y) Z4C_INLINE {
        return dgu(a, x)(c) * gu(b, y) * A(x, y)   //
               + gu(a, x) * dgu(b, y)(c) * A(x, y) //
               + gu(a, x) * gu(b, y) * dA(x, y)(c);

Insertion in Z4c/src/physics.hxx at line 39 [3.31007]
[5.14325]
[3.32490]
```
    });
  });
```

Replacement in Z4c/src/physics.hxx at line 44 [3.31007]

B:BD[3.32515] → [2.76360:76425]

CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr vec3<mat3<T, DN, DN>, DN>

[3.32515]

[4.6034]

Z4C_INLINE constexpr vec3<mat3<T, DN, DN>, DN>

Replacement in Z4c/src/physics.hxx at line 47 [3.31007]

B:BD[3.32731] → [2.76426:76579]

  return vec3<mat3<T, DN, DN>, DN>([&](int a) CCTK_ATTRIBUTE_ALWAYS_INLINE {
    return mat3<T, DN, DN>([&](int b, int c) CCTK_ATTRIBUTE_ALWAYS_INLINE {

[3.32731]

[5.14514]

  return vec3<mat3<T, DN, DN>, DN>([&](int a) Z4C_INLINE {
    return mat3<T, DN, DN>([&](int b, int c) Z4C_INLINE {

Replacement in Z4c/src/physics.hxx at line 55 [3.31007]

B:BD[3.33355] → [2.76580:76645]

CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr vec3<mat3<T, DN, DN>, UP>

[3.33355]

[4.6250]

Z4C_INLINE constexpr vec3<mat3<T, DN, DN>, UP>

Replacement in Z4c/src/physics.hxx at line 58 [3.31007]

B:BD[5.14725] → [2.76646:76912]

  return vec3<mat3<T, DN, DN>, UP>([&](int a) CCTK_ATTRIBUTE_ALWAYS_INLINE {
    return mat3<T, DN, DN>([&](int b, int c) CCTK_ATTRIBUTE_ALWAYS_INLINE {
      return sum1([&](int x) CCTK_ATTRIBUTE_ALWAYS_INLINE {
        return gu(a, x) * Gammal(x)(b, c);
      });

[5.14725]

[5.14871]

  return vec3<mat3<T, DN, DN>, UP>([&](int a) Z4C_INLINE {
    return mat3<T, DN, DN>([&](int b, int c) Z4C_INLINE {
      return sum1([&](int x) Z4C_INLINE { return gu(a, x) * Gammal(x)(b, c); });

Insertion in Z4c/src/tensor.hxx at line 14 [3.48124]

[5.24639]

[3.48270]


#ifdef CCTK_DEBUG
#define Z4C_INLINE
#else
#define Z4C_INLINE CCTK_ATTRIBUTE_ALWAYS_INLINE
#endif

Replacement in Z4c/src/tensor.hxx at line 25 [3.48124]

B:BD[3.48331] → [2.84149:84230]

∅:D[2.84230] → [5.24725:24743]

B:BD[5.24725] → [5.24725:24743]

B:BD[5.24743] → [2.84231:84312]

template <typename T> CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr T pow2(const T x) {
  return x * x;
}
template <typename T> CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr T pow3(const T x) {

[3.48331]

[2.84312]

template <typename T> Z4C_INLINE constexpr T pow2(const T x) { return x * x; }
template <typename T> Z4C_INLINE constexpr T pow3(const T x) {

Replacement in Z4c/src/tensor.hxx at line 30 [3.48124]

B:BD[5.24852] → [2.84352:84433]

template <typename T> CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr T pow4(const T x) {

[5.24852]

[2.84433]

template <typename T> Z4C_INLINE constexpr T pow4(const T x) {

Replacement in Z4c/src/tensor.hxx at line 34 [3.48124]

B:BD[2.84475] → [2.84475:84556]

template <typename T> CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr T pow5(const T x) {

[2.84475]

[2.84556]

template <typename T> Z4C_INLINE constexpr T pow5(const T x) {

Replacement in Z4c/src/tensor.hxx at line 39 [3.48124]

B:BD[2.84621] → [2.84621:84702]

template <typename T> CCTK_ATTRIBUTE_ALWAYS_INLINE constexpr T pow6(const T x) {

[2.84621]

[2.84702]

template <typename T> Z4C_INLINE constexpr T pow6(const T x) {

Replacement in Z4c/src/tensor.hxx at line 75 [3.48124]

B:BD[3.48517] → [2.85209:85287]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T operator()() const { return NAN; }

[3.48517]

[3.48572]

  constexpr Z4C_INLINE T operator()() const { return NAN; }

Replacement in Z4c/src/tensor.hxx at line 78 [3.48124]

B:BD[3.48630] → [2.85288:85361]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vect<T, D> operator()() const {

[3.48630]

[3.48674]

  constexpr Z4C_INLINE vect<T, D> operator()() const {

Replacement in Z4c/src/tensor.hxx at line 85 [3.48124]
B:BD[5.25193] → [2.85362:85415]
∅:D[2.85415] → [5.25250:25283]
B:BD[5.25250] → [5.25250:25283]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE result_type
  operator()(const T &x) const {
```
[5.25193]
[5.25283]
```
  constexpr Z4C_INLINE result_type operator()(const T &x) const {
```

Replacement in Z4c/src/tensor.hxx at line 91 [3.48124]

B:BD[5.25420] → [2.85416:85469]

∅:D[2.85469] → [5.25477:25520]

B:BD[5.25477] → [5.25477:25520]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE result_type
  operator()(const vect<T, D> &xs) const {

[5.25420]

[5.25520]

  constexpr Z4C_INLINE result_type operator()(const vect<T, D> &xs) const {

Replacement in Z4c/src/tensor.hxx at line 110 [3.48124]

B:BD[3.48872] → [2.85470:85541]

  static constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE int ind(const int n) {

[3.48872]

[5.25728]

  static constexpr Z4C_INLINE int ind(const int n) {

Replacement in Z4c/src/tensor.hxx at line 118 [3.48124]

B:BD[3.48970] → [2.85542:85599]

∅:D[2.85599] → [5.25816:25854]

B:BD[5.25816] → [5.25816:25854]

  explicit constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3()
      : elts{nan<vect<T, 3> >()()} {}

[3.48970]

[3.49030]

  explicit constexpr Z4C_INLINE vec3() : elts{nan<vect<T, 3> >()()} {}

Replacement in Z4c/src/tensor.hxx at line 120 [3.48124]

B:BD[3.49031] → [2.85600:85670]

∅:D[2.85670] → [5.25929:25951]

B:BD[5.25929] → [5.25929:25951]

B:BD[5.25951] → [2.85671:85736]

∅:D[2.85736] → [5.26020:26048]

B:BD[5.26020] → [5.26020:26048]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(const vect<T, 3> &elts)
      : elts(elts) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(vect<T, 3> &&elts)
      : elts(move(elts)) {}

[3.49031]

[3.49084]

  constexpr Z4C_INLINE vec3(const vect<T, 3> &elts) : elts(elts) {}
  constexpr Z4C_INLINE vec3(vect<T, 3> &&elts) : elts(move(elts)) {}

Replacement in Z4c/src/tensor.hxx at line 124 [3.48124]

B:BD[2.85746] → [2.85746:85838]

  static constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vector<T>
  make_vector(T vx, T vy, T vz) {

[2.85746]

[2.85838]

  static constexpr Z4C_INLINE vector<T> make_vector(T vx, T vy, T vz) {

Replacement in Z4c/src/tensor.hxx at line 134 [3.48124]

B:BD[2.85993] → [2.85993:86066]

  explicit constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(T vx, T vy, T vz)

[2.85993]

[2.86066]

  explicit constexpr Z4C_INLINE vec3(T vx, T vy, T vz)

Replacement in Z4c/src/tensor.hxx at line 137 [3.48124]

B:BD[2.86126] → [2.86126:86195]

∅:D[2.86195] → [5.26122:26141]

B:BD[5.26122] → [5.26122:26141]

B:BD[5.26141] → [2.86196:86355]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(initializer_list<T> v)
      : elts(v) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(const vector<T> &v) : elts(v) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(vector<T> &&v) : elts(move(v)) {}

[2.86126]

[5.26141]

  constexpr Z4C_INLINE vec3(initializer_list<T> v) : elts(v) {}
  constexpr Z4C_INLINE vec3(const vector<T> &v) : elts(v) {}
  constexpr Z4C_INLINE vec3(vector<T> &&v) : elts(move(v)) {}

Replacement in Z4c/src/tensor.hxx at line 141 [3.48124]
B:BD[5.26142] → [2.86356:86387]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.26142]
[2.86387]
```
  Z4C_INLINE
```
Replacement in Z4c/src/tensor.hxx at line 147 [3.48124]
B:BD[3.49296] → [2.86567:86598]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[3.49296]
[2.86598]
```
  Z4C_INLINE
```
Replacement in Z4c/src/tensor.hxx at line 154 [3.48124]
B:BD[5.26694] → [2.86787:86845]
∅:D[2.86845] → [5.26756:26790]
B:BD[5.26756] → [5.26756:26790]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3(const F &f)
      : elts{f(0), f(1), f(2)} {}
```
[5.26694]
[3.49481]
```
  constexpr Z4C_INLINE vec3(const F &f) : elts{f(0), f(1), f(2)} {}
```

Replacement in Z4c/src/tensor.hxx at line 160 [3.48124]

B:BD[2.86987] → [2.86987:87282]

  CCTK_ATTRIBUTE_ALWAYS_INLINE void store(const GF3D<T, 0, 0, 0> &gf_vx_,
                                          const GF3D<T, 0, 0, 0> &gf_vy_,
                                          const GF3D<T, 0, 0, 0> &gf_vz_,
                                          const vect<int, 3> &I) const {

[2.86987]

[3.49632]

  Z4C_INLINE void store(const GF3D<T, 0, 0, 0> &gf_vx_,
                        const GF3D<T, 0, 0, 0> &gf_vy_,
                        const GF3D<T, 0, 0, 0> &gf_vz_,
                        const vect<int, 3> &I) const {

Replacement in Z4c/src/tensor.hxx at line 181 [3.48124]

B:BD[3.49854] → [2.87350:87416]

∅:D[2.87416] → [5.27361:27390]

B:BD[5.27361] → [5.27361:27390]

B:BD[5.27390] → [2.87417:87494]

  CCTK_ATTRIBUTE_ALWAYS_INLINE const T &operator()(int i) const {
    return elts[ind(i)];
  }
  CCTK_ATTRIBUTE_ALWAYS_INLINE T &operator()(int i) { return elts[ind(i)]; }

[3.49854]

[5.27391]

  Z4C_INLINE const T &operator()(int i) const { return elts[ind(i)]; }
  Z4C_INLINE T &operator()(int i) { return elts[ind(i)]; }

Replacement in Z4c/src/tensor.hxx at line 185 [3.48124]
B:BD[2.87523] → [2.87523:87554]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[2.87523]
[2.87554]
```
  Z4C_INLINE
```

Replacement in Z4c/src/tensor.hxx at line 192 [3.48124]

B:BD[2.87749] → [2.87749:87811]

∅:D[2.87811] → [4.7180:7218]

B:BD[4.7180] → [4.7180:7218]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup>
  operator+(const vec3<T, dnup> &x) {

[2.87749]

[5.27484]

  friend constexpr Z4C_INLINE vec3<T, dnup> operator+(const vec3<T, dnup> &x) {

Replacement in Z4c/src/tensor.hxx at line 195 [3.48124]

B:BD[5.27510] → [2.87812:87874]

∅:D[2.87874] → [4.7285:7323]

B:BD[4.7285] → [4.7285:7323]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup>
  operator-(const vec3<T, dnup> &x) {

[5.27510]

[5.27602]

  friend constexpr Z4C_INLINE vec3<T, dnup> operator-(const vec3<T, dnup> &x) {

Replacement in Z4c/src/tensor.hxx at line 198 [3.48124]

B:BD[5.27628] → [2.87875:87937]

∅:D[2.87937] → [4.7390:7452]

B:BD[4.7390] → [4.7390:7452]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup>
  operator+(const vec3<T, dnup> &x, const vec3<T, dnup> &y) {

[5.27628]

[5.27738]

  friend constexpr Z4C_INLINE vec3<T, dnup> operator+(const vec3<T, dnup> &x,
                                                      const vec3<T, dnup> &y) {

Replacement in Z4c/src/tensor.hxx at line 202 [3.48124]

B:BD[5.27772] → [2.87938:88000]

∅:D[2.88000] → [4.7519:7581]

B:BD[4.7519] → [4.7519:7581]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup>
  operator-(const vec3<T, dnup> &x, const vec3<T, dnup> &y) {

[5.27772]

[5.27882]

  friend constexpr Z4C_INLINE vec3<T, dnup> operator-(const vec3<T, dnup> &x,
                                                      const vec3<T, dnup> &y) {

Replacement in Z4c/src/tensor.hxx at line 206 [3.48124]

B:BD[5.27916] → [2.88001:88063]

∅:D[2.88063] → [4.7648:7698]

B:BD[4.7648] → [4.7648:7698]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup>
  operator*(const T &a, const vec3<T, dnup> &x) {

[5.27916]

[5.28020]

  friend constexpr Z4C_INLINE vec3<T, dnup> operator*(const T &a,
                                                      const vec3<T, dnup> &x) {

Replacement in Z4c/src/tensor.hxx at line 211 [3.48124]

B:BD[5.28050] → [2.88064:88117]

∅:D[2.88117] → [4.7699:7762]

B:BD[5.28107] → [4.7699:7762]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE bool
  operator==(const vec3<T, dnup> &x, const vec3<T, dnup> &y) {

[5.28050]

[5.28158]

  friend constexpr Z4C_INLINE bool operator==(const vec3<T, dnup> &x,
                                              const vec3<T, dnup> &y) {

Replacement in Z4c/src/tensor.hxx at line 215 [3.48124]

B:BD[5.28214] → [2.88118:88171]

∅:D[2.88171] → [4.7763:7826]

B:BD[5.28271] → [4.7763:7826]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE bool
  operator!=(const vec3<T, dnup> &x, const vec3<T, dnup> &y) {

[5.28214]

[5.28322]

  friend constexpr Z4C_INLINE bool operator!=(const vec3<T, dnup> &x,
                                              const vec3<T, dnup> &y) {

Replacement in Z4c/src/tensor.hxx at line 220 [3.48124]
B:BD[3.49963] → [2.88172:88232]
∅:D[2.88232] → [5.28413:28443]
B:BD[5.28413] → [5.28413:28443]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T maxabs() const {
    return elts.maxabs();
  }
```
[3.49963]
[5.28443]
```
  constexpr Z4C_INLINE T maxabs() const { return elts.maxabs(); }
```

Replacement in Z4c/src/tensor.hxx at line 230 [3.48124]

B:BD[4.7960] → [2.88233:88309]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vec3<T, dnup> operator()() const {

[4.7960]

[4.8040]

  constexpr Z4C_INLINE vec3<T, dnup> operator()() const {

Replacement in Z4c/src/tensor.hxx at line 237 [3.48124]

B:BD[5.28692] → [2.88310:88363]

∅:D[2.88363] → [4.8136:8181]

B:BD[5.28749] → [4.8136:8181]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE result_type
  operator()(const vec3<T, dnup> &x) const {

[5.28692]

[5.28788]

  constexpr Z4C_INLINE result_type operator()(const vec3<T, dnup> &x) const {

Replacement in Z4c/src/tensor.hxx at line 250 [3.48124]

B:BD[3.50368] → [2.88364:88510]

  static constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE int symind(const int i,
                                                           const int j) {

[3.50368]

[5.28988]

  static constexpr Z4C_INLINE int symind(const int i, const int j) {

Replacement in Z4c/src/tensor.hxx at line 268 [3.48124]

B:BD[3.50559] → [2.88511:88651]

  static constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE int ind(const int i,
                                                        const int j) {

[3.50559]

[3.50614]

  static constexpr Z4C_INLINE int ind(const int i, const int j) {

Replacement in Z4c/src/tensor.hxx at line 284 [3.48124]

B:BD[3.51045] → [2.88652:88709]

∅:D[2.88709] → [5.29393:29431]

B:BD[5.29393] → [5.29393:29431]

  explicit constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3()
      : elts{nan<vect<T, 6> >()()} {}

[3.51045]

[3.51105]

  explicit constexpr Z4C_INLINE mat3() : elts{nan<vect<T, 6> >()()} {}

Replacement in Z4c/src/tensor.hxx at line 286 [3.48124]

B:BD[3.51106] → [2.88710:88780]

∅:D[2.88780] → [5.29506:29528]

B:BD[5.29506] → [5.29506:29528]

B:BD[5.29528] → [2.88781:88846]

∅:D[2.88846] → [5.29597:29625]

B:BD[5.29597] → [5.29597:29625]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(const vect<T, 6> &elts)
      : elts(elts) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(vect<T, 6> &&elts)
      : elts(move(elts)) {}

[3.51106]

[3.51159]

  constexpr Z4C_INLINE mat3(const vect<T, 6> &elts) : elts(elts) {}
  constexpr Z4C_INLINE mat3(vect<T, 6> &&elts) : elts(move(elts)) {}

Replacement in Z4c/src/tensor.hxx at line 290 [3.48124]

B:BD[2.88856] → [2.88856:88972]

  static constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE vector<T>
  make_vector(T Axx, T Axy, T Axz, T Ayy, T Ayz, T Azz) {

[2.88856]

[2.88972]

  static constexpr Z4C_INLINE vector<T> make_vector(T Axx, T Axy, T Axz, T Ayy,
                                                    T Ayz, T Azz) {

Replacement in Z4c/src/tensor.hxx at line 304 [3.48124]

B:BD[2.89220] → [2.89220:89372]

  explicit constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(T Axx, T Axy, T Axz,
                                                       T Ayy, T Ayz, T Azz)

[2.89220]

[2.89372]

  explicit constexpr Z4C_INLINE mat3(T Axx, T Axy, T Axz, T Ayy, T Ayz, T Azz)

Replacement in Z4c/src/tensor.hxx at line 308 [3.48124]

B:BD[2.89493] → [2.89493:89562]

∅:D[2.89562] → [5.29699:29718]

B:BD[5.29699] → [5.29699:29718]

B:BD[5.29718] → [2.89563:89722]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(initializer_list<T> A)
      : elts(A) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(const vector<T> &A) : elts(A) {}
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(vector<T> &&A) : elts(move(A)) {}

[2.89493]

[5.29718]

  constexpr Z4C_INLINE mat3(initializer_list<T> A) : elts(A) {}
  constexpr Z4C_INLINE mat3(const vector<T> &A) : elts(A) {}
  constexpr Z4C_INLINE mat3(vector<T> &&A) : elts(move(A)) {}

Replacement in Z4c/src/tensor.hxx at line 312 [3.48124]
B:BD[5.29719] → [2.89723:89754]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.29719]
[2.89754]
```
  Z4C_INLINE
```
Replacement in Z4c/src/tensor.hxx at line 322 [3.48124]
B:BD[3.51570] → [2.90096:90127]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[3.51570]
[2.90127]
```
  Z4C_INLINE
```
Replacement in Z4c/src/tensor.hxx at line 333 [3.48124]
B:BD[5.30588] → [2.90487:90545]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3(const F &f)
```
[5.30588]
[5.30650]
```
  constexpr Z4C_INLINE mat3(const F &f)
```
Replacement in Z4c/src/tensor.hxx at line 366 [3.48124]
B:BD[2.90769] → [2.90769:90805]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE void
```
[2.90769]
[5.31661]
```
  Z4C_INLINE void
```

Replacement in Z4c/src/tensor.hxx at line 388 [3.48124]

B:BD[3.52637] → [2.91003:91076]

∅:D[2.91076] → [5.31997:32029]

B:BD[5.31997] → [5.31997:32029]

B:BD[5.32029] → [2.91077:91148]

  CCTK_ATTRIBUTE_ALWAYS_INLINE const T &operator()(int i, int j) const {
    return elts[ind(i, j)];
  }
  // CCTK_ATTRIBUTE_ALWAYS_INLINE T &operator()(int i, int j) { return

[3.52637]

[5.32104]

  Z4C_INLINE const T &operator()(int i, int j) const { return elts[ind(i, j)]; }
  // Z4C_INLINE T &operator()(int i, int j) { return

Replacement in Z4c/src/tensor.hxx at line 391 [3.48124]
B:BD[5.32131] → [2.91149:91210]
∅:D[2.91210] → [5.32196:32228]
B:BD[5.32196] → [5.32196:32228]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE T &operator()(int i, int j) {
    return elts[ind(i, j)];
  }
```
[5.32131]
[5.32228]
```
  Z4C_INLINE T &operator()(int i, int j) { return elts[ind(i, j)]; }
```
Replacement in Z4c/src/tensor.hxx at line 394 [3.48124]
B:BD[2.91239] → [2.91239:91270]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[2.91239]
[2.91270]
```
  Z4C_INLINE
```

Replacement in Z4c/src/tensor.hxx at line 402 [3.48124]

B:BD[2.91521] → [2.91521:91591]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>

[2.91521]

[4.8575]

  friend constexpr Z4C_INLINE mat3<T, dnup1, dnup2>

Replacement in Z4c/src/tensor.hxx at line 406 [3.48124]

B:BD[5.32347] → [2.91592:91662]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>

[5.32347]

[4.8696]

  friend constexpr Z4C_INLINE mat3<T, dnup1, dnup2>

Replacement in Z4c/src/tensor.hxx at line 410 [3.48124]

B:BD[5.32465] → [2.91663:91733]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>

[5.32465]

[4.8817]

  friend constexpr Z4C_INLINE mat3<T, dnup1, dnup2>

Replacement in Z4c/src/tensor.hxx at line 414 [3.48124]

B:BD[5.32609] → [2.91734:91804]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>

[5.32609]

[4.8970]

  friend constexpr Z4C_INLINE mat3<T, dnup1, dnup2>

Replacement in Z4c/src/tensor.hxx at line 418 [3.48124]

B:BD[5.32753] → [2.91805:91875]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>

[5.32753]

[4.9123]

  friend constexpr Z4C_INLINE mat3<T, dnup1, dnup2>

Replacement in Z4c/src/tensor.hxx at line 423 [3.48124]

B:BD[3.52830] → [2.91876:91929]

∅:D[2.91929] → [4.9182:9261]

B:BD[5.32944] → [4.9182:9261]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE bool
  operator==(const mat3<T, dnup1, dnup2> &x, const mat3<T, dnup1, dnup2> &y) {

[3.52830]

[5.32995]

  friend constexpr Z4C_INLINE bool operator==(const mat3<T, dnup1, dnup2> &x,
                                              const mat3<T, dnup1, dnup2> &y) {

Replacement in Z4c/src/tensor.hxx at line 427 [3.48124]

B:BD[5.33051] → [2.91930:91983]

∅:D[2.91983] → [4.9262:9341]

B:BD[5.33108] → [4.9262:9341]

  friend constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE bool
  operator!=(const mat3<T, dnup1, dnup2> &x, const mat3<T, dnup1, dnup2> &y) {

[5.33051]

[5.33159]

  friend constexpr Z4C_INLINE bool operator!=(const mat3<T, dnup1, dnup2> &x,
                                              const mat3<T, dnup1, dnup2> &y) {

Replacement in Z4c/src/tensor.hxx at line 432 [3.48124]
B:BD[5.33186] → [2.91984:92044]
∅:D[2.92044] → [5.33250:33280]
B:BD[5.33250] → [5.33250:33280]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T maxabs() const {
    return elts.maxabs();
  }
```
[5.33186]
[5.33280]
```
  constexpr Z4C_INLINE T maxabs() const { return elts.maxabs(); }
```
Replacement in Z4c/src/tensor.hxx at line 436 [3.48124]
B:BD[5.33311] → [2.92045:92102]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T det() const {
```
[5.33311]
[3.52858]
```
  constexpr Z4C_INLINE T det() const {
```

Replacement in Z4c/src/tensor.hxx at line 443 [3.48124]

B:BD[3.53078] → [2.92103:92168]

∅:D[2.92168] → [4.9411:9439]

B:BD[4.9411] → [4.9411:9439]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, !dnup1, !dnup2>
  inv(const T detA) const {

[3.53078]

[3.53121]

  constexpr Z4C_INLINE mat3<T, !dnup1, !dnup2> inv(const T detA) const {

Replacement in Z4c/src/tensor.hxx at line 455 [3.48124]

B:BD[3.53574] → [2.92169:92212]

∅:D[2.92212] → [4.9867:9918]

B:BD[4.9867] → [4.9867:9918]

  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T
  trace(const mat3<T, !dnup1, !dnup2> &gu) const {

[3.53574]

[5.33853]

  constexpr Z4C_INLINE T trace(const mat3<T, !dnup1, !dnup2> &gu) const {

Replacement in Z4c/src/tensor.hxx at line 457 [3.48124]

B:BD[5.33880] → [2.92213:92319]

    return sum2([&](int x, int y) CCTK_ATTRIBUTE_ALWAYS_INLINE {
      return gu(x, y) * A(x, y);
    });

[5.33880]

[5.33947]

    return sum2([&](int x, int y) Z4C_INLINE { return gu(x, y) * A(x, y); });

Replacement in Z4c/src/tensor.hxx at line 460 [3.48124]
B:BD[5.33952] → [2.92320:92378]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3 trace_free(
```
[5.33952]
[4.9981]
```
  constexpr Z4C_INLINE mat3 trace_free(
```

Replacement in Z4c/src/tensor.hxx at line 464 [3.48124]

B:BD[5.34086] → [2.92379:92494]

    return mat3([&](int a, int b) CCTK_ATTRIBUTE_ALWAYS_INLINE {
      return A(a, b) - trA / 3 * g(a, b);
    });

[5.34086]

[3.53671]

    return mat3([&](int a, int b)
                    Z4C_INLINE { return A(a, b) - trA / 3 * g(a, b); });

Replacement in Z4c/src/tensor.hxx at line 476 [3.48124]
B:BD[4.10227] → [2.92495:92558]
∅:D[2.92558] → [4.10294:10317]
B:BD[4.10294] → [4.10294:10317]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>
  operator()() const {
```
[4.10227]
[4.10317]
```
  constexpr Z4C_INLINE mat3<T, dnup1, dnup2> operator()() const {
```
Replacement in Z4c/src/tensor.hxx at line 484 [3.48124]
B:BD[5.34378] → [2.92559:92612]
```
  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE result_type
```
[5.34378]
[4.10444]
```
  constexpr Z4C_INLINE result_type
```
Replacement in Z4c/src/tensor.hxx at line 491 [3.48124]
B:BD[4.10562] → [2.92613:92674]
```
constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE mat3<T, dnup1, dnup2>
```
[4.10562]
[4.10627]
```
constexpr Z4C_INLINE mat3<T, dnup1, dnup2>
```

Replacement in Z4c/src/tensor.hxx at line 494 [3.48124]

B:BD[3.54196] → [2.92675:92863]

  return mat3<T, dnup1, dnup2>([&](int a, int b) CCTK_ATTRIBUTE_ALWAYS_INLINE {
    return sum1([&](int x)
                    CCTK_ATTRIBUTE_ALWAYS_INLINE { return A(a, x) * B(x, b); });

[3.54196]

[5.34765]

  return mat3<T, dnup1, dnup2>([&](int a, int b) Z4C_INLINE {
    return sum1([&](int x) Z4C_INLINE { return A(a, x) * B(x, b); });

Replacement in Z4c/src/tensor.hxx at line 500 [3.48124]

B:BD[4.10785] → [2.92864:92936]

constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T fold(const F &f, const T &x) {

[4.10785]

[5.34859]

constexpr Z4C_INLINE T fold(const F &f, const T &x) {

Replacement in Z4c/src/tensor.hxx at line 504 [3.48124]

B:BD[4.10914] → [2.92937:93087]

constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T fold(const F &f, const T &x0,
                                              const T &x1, const Ts &... xs) {

[4.10914]

[4.11122]

constexpr Z4C_INLINE T fold(const F &f, const T &x0, const T &x1,
                            const Ts &... xs) {

Replacement in Z4c/src/tensor.hxx at line 509 [3.48124]
B:BD[4.11166] → [2.93088:93159]
∅:D[2.93159] → [4.11241:11258]
B:BD[4.11241] → [4.11241:11258]
```
template <typename T> constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T add() {
  return T(0);
}
```
[4.11166]
[4.11258]
```
template <typename T> constexpr Z4C_INLINE T add() { return T(0); }
```

Replacement in Z4c/src/tensor.hxx at line 511 [3.48124]

B:BD[4.11283] → [2.93160:93223]

//  constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T add(const T &x) {

[4.11283]

[4.11349]

//  constexpr Z4C_INLINE T add(const T &x) {

Replacement in Z4c/src/tensor.hxx at line 515 [3.48124]

B:BD[5.34911] → [2.93224:93301]

constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE T add(const T &x, const Ts &... xs) {

[5.34911]

[5.34992]

constexpr Z4C_INLINE T add(const T &x, const Ts &... xs) {

Replacement in Z4c/src/tensor.hxx at line 521 [3.48124]
B:BD[2.93404] → [2.93404:93464]
```
constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE R sum1(const F &f) {
```
[2.93404]
[2.93464]
```
constexpr Z4C_INLINE R sum1(const F &f) {
```
Replacement in Z4c/src/tensor.hxx at line 530 [3.48124]
B:BD[2.93599] → [2.93599:93659]
```
constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE R sum2(const F &f) {
```
[2.93599]
[2.93659]
```
constexpr Z4C_INLINE R sum2(const F &f) {
```
Replacement in Z4c/src/tensor.hxx at line 540 [3.48124]
B:BD[2.93799] → [2.93799:93859]
```
constexpr CCTK_ATTRIBUTE_ALWAYS_INLINE R sum3(const F &f) {
```
[2.93799]
[2.93859]
```
constexpr Z4C_INLINE R sum3(const F &f) {
```
Replacement in Z4c/src/z4c_vars.hxx at line 48 [5.40773]
B:BD[5.41724] → [2.97434:97465]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.41724]
[5.41759]
```
  Z4C_INLINE
```
Replacement in Z4c/src/z4c_vars.hxx at line 75 [5.40773]
B:BD[5.42772] → [2.97466:97497]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.42772]
[5.42807]
```
  Z4C_INLINE
```
Replacement in Z4c/src/z4c_vars.hxx at line 223 [5.40773]
B:BD[5.47804] → [2.97498:97529]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.47804]
[5.47839]
```
  Z4C_INLINE
```
Replacement in Z4c/src/z4c_vars.hxx at line 475 [5.40773]
B:BD[5.58623] → [2.97530:97561]
```
  CCTK_ATTRIBUTE_ALWAYS_INLINE
```
[5.58623]
[5.58658]
```
  Z4C_INLINE
```