// Copyright (c) the JPEG XL Project Authors. All rights reserved.

//

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include "lib/jxl/enc_modular_simd.h"

#include <cstdint>

#include "lib/jxl/base/common.h"

#include "lib/jxl/base/status.h"

#include "lib/jxl/dec_ans.h"

#include "lib/jxl/enc_ans_params.h"

#include "lib/jxl/memory_manager_internal.h"

#include "lib/jxl/modular/modular_image.h"

#undef HWY_TARGET_INCLUDE

#define HWY_TARGET_INCLUDE "lib/jxl/enc_modular_simd.cc"

#include <hwy/foreach_target.h>

#include <hwy/highway.h>

#if HWY_TARGET == HWY_SCALAR

#include "lib/jxl/modular/encoding/context_predict.h"

#include "lib/jxl/pack_signed.h"

#endif

HWY_BEFORE_NAMESPACE();

namespace jxl {

namespace HWY_NAMESPACE {

// These templates are not found via ADL.

using hwy::HWY_NAMESPACE::Add;

using hwy::HWY_NAMESPACE::And;

using hwy::HWY_NAMESPACE::Ge;

using hwy::HWY_NAMESPACE::GetLane;

using hwy::HWY_NAMESPACE::Gt;

using hwy::HWY_NAMESPACE::IfThenElse;

using hwy::HWY_NAMESPACE::IfThenElseZero;

using hwy::HWY_NAMESPACE::Iota;

using hwy::HWY_NAMESPACE::Load;

using hwy::HWY_NAMESPACE::LoadU;

using hwy::HWY_NAMESPACE::Lt;

using hwy::HWY_NAMESPACE::Max;

using hwy::HWY_NAMESPACE::Min;

using hwy::HWY_NAMESPACE::Mul;

using hwy::HWY_NAMESPACE::Not;

using hwy::HWY_NAMESPACE::Set;

using hwy::HWY_NAMESPACE::ShiftLeft;

using hwy::HWY_NAMESPACE::ShiftRight;

using hwy::HWY_NAMESPACE::Store;

using hwy::HWY_NAMESPACE::StoreU;

using hwy::HWY_NAMESPACE::Sub;

using hwy::HWY_NAMESPACE::Xor;

using hwy::HWY_NAMESPACE::Zero;

StatusOr<float> EstimateCost(const Image& img) {

  size_t histo_cost = 0;

  float histo_cost_frac = 0.0f;

  size_t extra_bits = 0;

#if HWY_TARGET == HWY_SCALAR

  HybridUintConfig config;

  uint32_t cutoffs[] = {0,  1,  3,  5,   7,   11,  15,  23, 31,

                        47, 63, 95, 127, 191, 255, 392, 500};

  constexpr size_t nc = sizeof(cutoffs) / sizeof(*cutoffs) + 1;

  Histogram histo[nc] = {};

  for (const Channel& ch : img.channel) {

    const ptrdiff_t onerow = ch.plane.PixelsPerRow();

    for (size_t y = 0; y < ch.h; y++) {

      const pixel_type* JXL_RESTRICT r = ch.Row(y);

      for (size_t x = 0; x < ch.w; x++) {

        pixel_type_w left = (x ? r[x - 1] : y ? *(r + x - onerow) : 0);

        pixel_type_w top = (y ? *(r + x - onerow) : left);

        pixel_type_w topleft = (x && y ? *(r + x - 1 - onerow) : left);

        size_t max_diff =

            std::max({left, top, topleft}) - std::min({left, top, topleft});

        size_t ctx = 0;

        for (uint32_t c : cutoffs) {

          ctx += (max_diff < c) ? 1 : 0;

        }

        pixel_type res = r[x] - ClampedGradient(top, left, topleft);

        uint32_t token;

        uint32_t nbits;

        uint32_t bits;

        config.Encode(PackSigned(res), &token, &nbits, &bits);

        histo[ctx].Add(token);

        extra_bits += nbits;

      }

    }

    for (auto& h : histo) {

      float f_cost = h.ShannonEntropy();

      size_t i_cost = f_cost;

      histo_cost += i_cost;

      histo_cost_frac += f_cost - i_cost;

      h.Clear();

    }

  }

#else

  JxlMemoryManager* memory_manager = img.memory_manager();

  const auto& ctx_map = estimate_cost_detail::ContextMap();

  const HWY_FULL(int32_t) di;

  const HWY_FULL(uint32_t) du;

  const HWY_FULL(float) df;

  const auto kOne = Set(du, 1);

  const auto kSplit = Set(du, 16);

  const auto kExpOffset2 = Set(du, 129);  // 127 + 2

  const auto kTokenBias = Set(du, 8);

  const auto kTokenMul = Set(du, 4);

  const auto kMsbMask = Set(du, 3);

  const auto kMaxDiffCap = Set(du, estimate_cost_detail::kLastThreshold - 1);

  const auto kLanes = Set(du, Lanes(du));

  const auto kIota = Iota(du, 0);

  const auto kLargeThreshold = Set(du, (1 << 22) - 1);

  constexpr size_t kLargeShiftVal = 10;

  const auto kLargeShift = Set(du, kLargeShiftVal);

  size_t max_w = 0;

  for (const Channel& ch : img.channel) {

    if (ch.h == 0) continue;

    max_w = std::max(max_w, ch.w);

  }

  max_w = RoundUpTo(max_w, Lanes(du));

  max_w = std::max(max_w, 2 * Lanes(du));

  JXL_ASSIGN_OR_RETURN(

      AlignedMemory buffer,

      AlignedMemory::Create(memory_manager, max_w * 2 * sizeof(uint32_t)));

  uint32_t* max_diff_row = buffer.address<uint32_t>();

  uint32_t* token_row = max_diff_row + max_w;

  int32_t* primer = buffer.address<int32_t>();

  int32_t* top_primer = primer + max_w;

  HybridUintConfig config;

  Histogram histo[estimate_cost_detail::kLastCtx + 1] = {};

  auto extra_bits_lanes = Zero(du);

  for (const Channel& ch : img.channel) {

    if (ch.h == 0 || ch.w == 0) continue;

    for (auto& h : histo) {

      h.EnsureCapacity(32 * 4);

    }

    const pixel_type* JXL_RESTRICT r = ch.Row(0);

    const pixel_type* JXL_RESTRICT last = primer;

    primer[0] = 0;

    StoreU(Load(di, r), di, primer + 1);

    auto pos = kIota;

    const auto last_pos = Set(du, ch.w);

    for (size_t x = 0; x < ch.w; x += Lanes(di)) {

      const auto left = LoadU(di, last);

      const auto central = Load(di, r + x);

      const auto ures = BitCast(du, Sub(central, left));

      const auto packed =

          Xor(ShiftLeft<1>(ures), Sub(ShiftRight<31>(Not(ures)), kOne));

      const auto is_large = Gt(packed, kLargeThreshold);

      const auto packed_shifted = ShiftRight<kLargeShiftVal>(packed);

      const auto not_literal = Ge(packed, kSplit);

      const auto packed_fixed = IfThenElse(is_large, packed_shifted, packed);

      const auto v = BitCast(du, ConvertTo(df, packed_fixed));

      const auto eb_raw = Sub(ShiftRight<23>(v), kExpOffset2);

      const auto eb = IfThenElse(is_large, Add(eb_raw, kLargeShift), eb_raw);

      const auto token = Add(Add(kTokenBias, Mul(eb, kTokenMul)),

                             And(ShiftRight<21>(v), kMsbMask));

      const auto tail_mask = Lt(pos, last_pos);

      const auto eb_fixed = IfThenElseZero(not_literal, eb);

      const auto token_fixed = IfThenElse(not_literal, token, packed);

      extra_bits_lanes =

          Add(extra_bits_lanes, IfThenElseZero(tail_mask, eb_fixed));

      Store(token_fixed, du, token_row + x);

      pos = Add(pos, kLanes);

      last = r + x + Lanes(di) - 1;

    }

    for (size_t x = 0; x < ch.w; x++) {

      histo[0].FastAdd(token_row[x]);

    }

    for (size_t y = 1; y < ch.h; y++) {

      r = ch.Row(y);

      const pixel_type* JXL_RESTRICT t = ch.Row(y - 1);

      last = primer;

      primer[0] = t[0];

      StoreU(Load(di, r), di, primer + 1);

      top_primer[0] = t[0];

      StoreU(Load(di, t), di, top_primer + 1);

      const pixel_type* JXL_RESTRICT top_last = top_primer;

      pos = kIota;

      for (size_t x = 0; x < ch.w; x += Lanes(di)) {

        const auto left = LoadU(di, last);

        const auto central = Load(di, r + x);

        const auto topleft = LoadU(di, top_last);

        const auto top = Load(di, t + x);

        const auto l_ge_t = Ge(left, top);

        const auto m = IfThenElse(l_ge_t, top, left);

        const auto M = IfThenElse(l_ge_t, left, top);

        const auto maxx = Max(topleft, M);

        const auto minn = Min(topleft, m);

        const auto max_diff = BitCast(du, Sub(maxx, minn));

        Store(Min(max_diff, kMaxDiffCap), du, max_diff_row + x);

        const auto overshoot = Lt(topleft, m);

        const auto undershoot = Gt(topleft, M);

        const auto grad =

            BitCast(di, Sub(Add(BitCast(du, top), BitCast(du, left)),

                            BitCast(du, topleft)));

        const auto prediction =

            IfThenElse(undershoot, m, IfThenElse(overshoot, M, grad));

        const auto ures = BitCast(du, Sub(central, prediction));

        const auto packed =

            Xor(ShiftLeft<1>(ures), Sub(ShiftRight<31>(Not(ures)), kOne));

        const auto is_large = Gt(packed, kLargeThreshold);

        const auto packed_shifted = ShiftRight<kLargeShiftVal>(packed);

        const auto not_literal = Ge(packed, kSplit);

        const auto packed_fixed = IfThenElse(is_large, packed_shifted, packed);

        const auto v = BitCast(du, ConvertTo(df, packed_fixed));

        const auto eb_raw = Sub(ShiftRight<23>(v), kExpOffset2);

        const auto eb = IfThenElse(is_large, Add(eb_raw, kLargeShift), eb_raw);

        const auto token = Add(Add(kTokenBias, Mul(eb, kTokenMul)),

                               And(ShiftRight<21>(v), kMsbMask));

        const auto tail_mask = Lt(pos, last_pos);

        const auto eb_fixed = IfThenElseZero(not_literal, eb);

        const auto token_fixed = IfThenElse(not_literal, token, packed);

        extra_bits_lanes =

            Add(extra_bits_lanes, IfThenElseZero(tail_mask, eb_fixed));

        Store(token_fixed, du, token_row + x);

        pos = Add(pos, kLanes);

        last = r + x + Lanes(di) - 1;

        top_last = t + x + Lanes(di) - 1;

      }

      for (size_t x = 0; x < ch.w; x++) {

        size_t ctx = ctx_map[max_diff_row[x]];

        histo[ctx].FastAdd(token_row[x]);

      }

    }

    for (auto& h : histo) {

      h.Condition();

      float f_cost = h.ShannonEntropy();

      size_t i_cost = f_cost;

      histo_cost += i_cost;

      histo_cost_frac += f_cost - i_cost;

      h.Clear();

    }

  }

  extra_bits = GetLane(SumOfLanes(du, extra_bits_lanes));

#endif

  size_t total_cost =

      extra_bits + histo_cost + static_cast<size_t>(histo_cost_frac);

  return total_cost;

}

Unexecuted instantiation: jxl::N_SSE4::EstimateCost(jxl::Image const&)

jxl::N_AVX2::EstimateCost(jxl::Image const&)

Line

Count

Source

56

1.04k

StatusOr<float> EstimateCost(const Image& img) {

57

1.04k

  size_t histo_cost = 0;

58

1.04k

  float histo_cost_frac = 0.0f;

59

1.04k

  size_t extra_bits = 0;

60

61

#if HWY_TARGET == HWY_SCALAR

62

  HybridUintConfig config;

63

  uint32_t cutoffs[] = {0,  1,  3,  5,   7,   11,  15,  23, 31,

64

                        47, 63, 95, 127, 191, 255, 392, 500};

65

  constexpr size_t nc = sizeof(cutoffs) / sizeof(*cutoffs) + 1;

66

  Histogram histo[nc] = {};

67

  for (const Channel& ch : img.channel) {

68

    const ptrdiff_t onerow = ch.plane.PixelsPerRow();

69

    for (size_t y = 0; y < ch.h; y++) {

70

      const pixel_type* JXL_RESTRICT r = ch.Row(y);

71

      for (size_t x = 0; x < ch.w; x++) {

72

        pixel_type_w left = (x ? r[x - 1] : y ? *(r + x - onerow) : 0);

73

        pixel_type_w top = (y ? *(r + x - onerow) : left);

74

        pixel_type_w topleft = (x && y ? *(r + x - 1 - onerow) : left);

75

        size_t max_diff =

76

            std::max({left, top, topleft}) - std::min({left, top, topleft});

77

        size_t ctx = 0;

78

        for (uint32_t c : cutoffs) {

79

          ctx += (max_diff < c) ? 1 : 0;

80

        }

81

        pixel_type res = r[x] - ClampedGradient(top, left, topleft);

82

        uint32_t token;

83

        uint32_t nbits;

84

        uint32_t bits;

85

        config.Encode(PackSigned(res), &token, &nbits, &bits);

86

        histo[ctx].Add(token);

87

        extra_bits += nbits;

88

      }

89

    }

90

    for (auto& h : histo) {

91

      float f_cost = h.ShannonEntropy();

92

      size_t i_cost = f_cost;

93

      histo_cost += i_cost;

94

      histo_cost_frac += f_cost - i_cost;

95

      h.Clear();

96

    }

97

  }

98

#else

99

1.04k

  JxlMemoryManager* memory_manager = img.memory_manager();

100

1.04k

  const auto& ctx_map = estimate_cost_detail::ContextMap();

101

1.04k

  const HWY_FULL(int32_t) di;

102

1.04k

  const HWY_FULL(uint32_t) du;

103

1.04k

  const HWY_FULL(float) df;

104

1.04k

  const auto kOne = Set(du, 1);

105

1.04k

  const auto kSplit = Set(du, 16);

106

1.04k

  const auto kExpOffset2 = Set(du, 129);  // 127 + 2

107

1.04k

  const auto kTokenBias = Set(du, 8);

108

1.04k

  const auto kTokenMul = Set(du, 4);

109

1.04k

  const auto kMsbMask = Set(du, 3);

110

1.04k

  const auto kMaxDiffCap = Set(du, estimate_cost_detail::kLastThreshold - 1);

111

1.04k

  const auto kLanes = Set(du, Lanes(du));

112

1.04k

  const auto kIota = Iota(du, 0);

113

1.04k

  const auto kLargeThreshold = Set(du, (1 << 22) - 1);

114

1.04k

  constexpr size_t kLargeShiftVal = 10;

115

1.04k

  const auto kLargeShift = Set(du, kLargeShiftVal);

116

117

1.04k

  size_t max_w = 0;

118

1.04k

  for (const Channel& ch : img.channel) {

119

1.04k

    if (ch.h == 0) continue;

120

1.04k

    max_w = std::max(max_w, ch.w);

121

1.04k

  }

122

1.04k

  max_w = RoundUpTo(max_w, Lanes(du));

123

1.04k

  max_w = std::max(max_w, 2 * Lanes(du));

124

125

1.04k

  JXL_ASSIGN_OR_RETURN(

126

1.04k

      AlignedMemory buffer,

127

1.04k

      AlignedMemory::Create(memory_manager, max_w * 2 * sizeof(uint32_t)));

128

1.04k

  uint32_t* max_diff_row = buffer.address<uint32_t>();

129

1.04k

  uint32_t* token_row = max_diff_row + max_w;

130

1.04k

  int32_t* primer = buffer.address<int32_t>();

131

1.04k

  int32_t* top_primer = primer + max_w;

132

133

1.04k

  HybridUintConfig config;

134

135

1.04k

  Histogram histo[estimate_cost_detail::kLastCtx + 1] = {};

136

1.04k

  auto extra_bits_lanes = Zero(du);

137

1.04k

  for (const Channel& ch : img.channel) {

138

1.04k

    if (ch.h == 0 || ch.w == 0) continue;

139

17.8k

    for (auto& h : histo) {

140

17.8k

      h.EnsureCapacity(32 * 4);

141

17.8k

    }

142

1.04k

    const pixel_type* JXL_RESTRICT r = ch.Row(0);

143

1.04k

    const pixel_type* JXL_RESTRICT last = primer;

144

1.04k

    primer[0] = 0;

145

1.04k

    StoreU(Load(di, r), di, primer + 1);

146

1.04k

    auto pos = kIota;

147

1.04k

    const auto last_pos = Set(du, ch.w);

148

26.4k

    for (size_t x = 0; x < ch.w; x += Lanes(di)) {

149

25.4k

      const auto left = LoadU(di, last);

150

25.4k

      const auto central = Load(di, r + x);

151

25.4k

      const auto ures = BitCast(du, Sub(central, left));

152

25.4k

      const auto packed =

153

25.4k

          Xor(ShiftLeft<1>(ures), Sub(ShiftRight<31>(Not(ures)), kOne));

154

25.4k

      const auto is_large = Gt(packed, kLargeThreshold);

155

25.4k

      const auto packed_shifted = ShiftRight<kLargeShiftVal>(packed);

156

25.4k

      const auto not_literal = Ge(packed, kSplit);

157

25.4k

      const auto packed_fixed = IfThenElse(is_large, packed_shifted, packed);

158

25.4k

      const auto v = BitCast(du, ConvertTo(df, packed_fixed));

159

25.4k

      const auto eb_raw = Sub(ShiftRight<23>(v), kExpOffset2);

160

25.4k

      const auto eb = IfThenElse(is_large, Add(eb_raw, kLargeShift), eb_raw);

161

25.4k

      const auto token = Add(Add(kTokenBias, Mul(eb, kTokenMul)),

162

25.4k

                             And(ShiftRight<21>(v), kMsbMask));

163

25.4k

      const auto tail_mask = Lt(pos, last_pos);

164

25.4k

      const auto eb_fixed = IfThenElseZero(not_literal, eb);

165

25.4k

      const auto token_fixed = IfThenElse(not_literal, token, packed);

166

25.4k

      extra_bits_lanes =

167

25.4k

          Add(extra_bits_lanes, IfThenElseZero(tail_mask, eb_fixed));

168

25.4k

      Store(token_fixed, du, token_row + x);

169

25.4k

      pos = Add(pos, kLanes);

170

25.4k

      last = r + x + Lanes(di) - 1;

171

25.4k

    }

172

201k

    for (size_t x = 0; x < ch.w; x++) {

173

200k

      histo[0].FastAdd(token_row[x]);

174

200k

    }

175

197k

    for (size_t y = 1; y < ch.h; y++) {

176

196k

      r = ch.Row(y);

177

196k

      const pixel_type* JXL_RESTRICT t = ch.Row(y - 1);

178

196k

      last = primer;

179

196k

      primer[0] = t[0];

180

196k

      StoreU(Load(di, r), di, primer + 1);

181

196k

      top_primer[0] = t[0];

182

196k

      StoreU(Load(di, t), di, top_primer + 1);

183

196k

      const pixel_type* JXL_RESTRICT top_last = top_primer;

184

196k

      pos = kIota;

185

8.77M

      for (size_t x = 0; x < ch.w; x += Lanes(di)) {

186

8.58M

        const auto left = LoadU(di, last);

187

8.58M

        const auto central = Load(di, r + x);

188

8.58M

        const auto topleft = LoadU(di, top_last);

189

8.58M

        const auto top = Load(di, t + x);

190

8.58M

        const auto l_ge_t = Ge(left, top);

191

8.58M

        const auto m = IfThenElse(l_ge_t, top, left);

192

8.58M

        const auto M = IfThenElse(l_ge_t, left, top);

193

8.58M

        const auto maxx = Max(topleft, M);

194

8.58M

        const auto minn = Min(topleft, m);

195

8.58M

        const auto max_diff = BitCast(du, Sub(maxx, minn));

196

8.58M

        Store(Min(max_diff, kMaxDiffCap), du, max_diff_row + x);

197

8.58M

        const auto overshoot = Lt(topleft, m);

198

8.58M

        const auto undershoot = Gt(topleft, M);

199

8.58M

        const auto grad =

200

8.58M

            BitCast(di, Sub(Add(BitCast(du, top), BitCast(du, left)),

201

8.58M

                            BitCast(du, topleft)));

202

8.58M

        const auto prediction =

203

8.58M

            IfThenElse(undershoot, m, IfThenElse(overshoot, M, grad));

204

8.58M

        const auto ures = BitCast(du, Sub(central, prediction));

205

8.58M

        const auto packed =

206

8.58M

            Xor(ShiftLeft<1>(ures), Sub(ShiftRight<31>(Not(ures)), kOne));

207

8.58M

        const auto is_large = Gt(packed, kLargeThreshold);

208

8.58M

        const auto packed_shifted = ShiftRight<kLargeShiftVal>(packed);

209

8.58M

        const auto not_literal = Ge(packed, kSplit);

210

8.58M

        const auto packed_fixed = IfThenElse(is_large, packed_shifted, packed);

211

8.58M

        const auto v = BitCast(du, ConvertTo(df, packed_fixed));

212

8.58M

        const auto eb_raw = Sub(ShiftRight<23>(v), kExpOffset2);

213

8.58M

        const auto eb = IfThenElse(is_large, Add(eb_raw, kLargeShift), eb_raw);

214

8.58M

        const auto token = Add(Add(kTokenBias, Mul(eb, kTokenMul)),

215

8.58M

                               And(ShiftRight<21>(v), kMsbMask));

216

8.58M

        const auto tail_mask = Lt(pos, last_pos);

217

8.58M

        const auto eb_fixed = IfThenElseZero(not_literal, eb);

218

8.58M

        const auto token_fixed = IfThenElse(not_literal, token, packed);

219

8.58M

        extra_bits_lanes =

220

8.58M

            Add(extra_bits_lanes, IfThenElseZero(tail_mask, eb_fixed));

221

8.58M

        Store(token_fixed, du, token_row + x);

222

8.58M

        pos = Add(pos, kLanes);

223

8.58M

        last = r + x + Lanes(di) - 1;

224

8.58M

        top_last = t + x + Lanes(di) - 1;

225

8.58M

      }

226

68.1M

      for (size_t x = 0; x < ch.w; x++) {

227

67.9M

        size_t ctx = ctx_map[max_diff_row[x]];

228

67.9M

        histo[ctx].FastAdd(token_row[x]);

229

67.9M

      }

230

196k

    }

231

17.8k

    for (auto& h : histo) {

232

17.8k

      h.Condition();

233

17.8k

      float f_cost = h.ShannonEntropy();

234

17.8k

      size_t i_cost = f_cost;

235

17.8k

      histo_cost += i_cost;

236

17.8k

      histo_cost_frac += f_cost - i_cost;

237

17.8k

      h.Clear();

238

17.8k

    }

239

1.04k

  }

240

1.04k

  extra_bits = GetLane(SumOfLanes(du, extra_bits_lanes));

241

1.04k

#endif

242

1.04k

  size_t total_cost =

243

1.04k

      extra_bits + histo_cost + static_cast<size_t>(histo_cost_frac);

244

1.04k

  return total_cost;

245

1.04k

}

Unexecuted instantiation: jxl::N_SSE2::EstimateCost(jxl::Image const&)

// NOLINTNEXTLINE(google-readability-namespace-comments)

}  // namespace HWY_NAMESPACE

}  // namespace jxl

HWY_AFTER_NAMESPACE();

#if HWY_ONCE

namespace jxl {

HWY_EXPORT(EstimateCost);

StatusOr<float> EstimateCost(const Image& img) {

  return HWY_DYNAMIC_DISPATCH(EstimateCost)(img);

}

namespace estimate_cost_detail {

/*

cutoffs = [0, 1, 3, 5, 7, 11, 15, 23, 31, 47, 63, 95, 127, 191, 255, 392, 500]

ctx_map = [[c for c,v in enumerate(cutoffs) if v <= i][0] for i in range(501)]

*/

const std::array<uint8_t, kLastThreshold>& ContextMap() {

  static const std::array<uint8_t, kLastThreshold> kCtxMap = {

      0,  1,  1,  2,  2,  3,  3,  4,  4,  4,  4,  5,  5,  5,  5,  6,  6,  6,

      6,  6,  6,  6,  6,  7,  7,  7,  7,  7,  7,  7,  7,  8,  8,  8,  8,  8,

      8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,

      9,  9,  9,  9,  9,  9,  9,  9,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10,

      10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,

      10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

      11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,

      11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

      12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

      12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,

      12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13,

      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

      13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,

      13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,

      14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,

      15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16};

  return kCtxMap;

}

}  // namespace estimate_cost_detail

}  // namespace jxl

#endif