Coverage Report

Created: 2026-09-17 11:25

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
be/src/exec/common/int_exp.h
Line
Count
Source
1
// Licensed to the Apache Software Foundation (ASF) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The ASF licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17
// This file is copied from
18
// https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/IntExp.h
19
// and modified by Doris
20
21
#pragma once
22
23
#include <cstdint>
24
#include <limits>
25
#include <utility>
26
27
#include "core/extended_types.h"
28
29
namespace exp_details {
30
31
// compile-time exp(v, n) by linear recursion
32
template <typename T, T v, std::size_t n>
33
constexpr inline const T exp = T(v) * exp<T, v, n - 1>;
34
35
template <typename T, T v>
36
constexpr inline const T exp<T, v, 0> = 1;
37
38
// compile-time exponentiation table { exp(v, I) ... }
39
template <typename T, T v, std::size_t... I>
40
constexpr inline const T exp_table[] = {exp<T, v, I>...};
41
42
// get value from compile-time exponentiation table by a (maybe) runtime offset
43
template <typename T, T v, std::size_t... I>
44
83.7k
constexpr T get_exp_helper(std::size_t x, std::index_sequence<I...>) {
45
83.7k
    return exp_table<T, v, I...>[x];
46
83.7k
}
47
48
// get_exp_helper with table { exp(v, 0), exp(v, 1) ... exp(v, N - 1) }
49
template <typename T, T v, std::size_t N>
50
83.7k
constexpr T get_exp(std::size_t x) {
51
83.7k
    return get_exp_helper<T, v>(x, std::make_index_sequence<N> {});
52
83.7k
}
53
54
} // namespace exp_details
55
56
83.7k
inline uint64_t int_exp10(int x) {
57
83.7k
    if (x < 0) {
58
0
        return 0;
59
0
    }
60
83.7k
    if (x > 19) {
61
0
        return std::numeric_limits<uint64_t>::max();
62
0
    }
63
64
83.7k
    return exp_details::get_exp<uint64_t, 10, 20>(x);
65
83.7k
}
66
67
namespace common {
68
69
515k
constexpr inline int exp10_i32(int x) {
70
515k
    if (x < 0) {
71
218
        return 0;
72
218
    }
73
515k
    if (x > 9) {
74
814
        return std::numeric_limits<int>::max();
75
814
    }
76
77
514k
    constexpr int values[] = {1,      10,      100,      1000,      10000,
78
514k
                              100000, 1000000, 10000000, 100000000, 1000000000};
79
514k
    return values[x];
80
515k
}
81
82
6.31M
constexpr inline int64_t exp10_i64(int x) {
83
6.31M
    if (x < 0) {
84
212
        return 0;
85
212
    }
86
6.31M
    if (x > 18) {
87
126
        return std::numeric_limits<int64_t>::max();
88
126
    }
89
90
6.31M
    constexpr int64_t values[] = {1LL,
91
6.31M
                                  10LL,
92
6.31M
                                  100LL,
93
6.31M
                                  1000LL,
94
6.31M
                                  10000LL,
95
6.31M
                                  100000LL,
96
6.31M
                                  1000000LL,
97
6.31M
                                  10000000LL,
98
6.31M
                                  100000000LL,
99
6.31M
                                  1000000000LL,
100
6.31M
                                  10000000000LL,
101
6.31M
                                  100000000000LL,
102
6.31M
                                  1000000000000LL,
103
6.31M
                                  10000000000000LL,
104
6.31M
                                  100000000000000LL,
105
6.31M
                                  1000000000000000LL,
106
6.31M
                                  10000000000000000LL,
107
6.31M
                                  100000000000000000LL,
108
6.31M
                                  1000000000000000000LL};
109
6.31M
    return values[x];
110
6.31M
}
111
112
1.32M
constexpr inline __int128 exp10_i128(int x) {
113
1.32M
    if (x < 0) {
114
288
        return 0;
115
288
    }
116
1.32M
    if (x > 38) {
117
76
        return std::numeric_limits<__int128>::max();
118
76
    }
119
120
1.32M
    constexpr __int128 values[] = {
121
1.32M
            static_cast<__int128>(1LL),
122
1.32M
            static_cast<__int128>(10LL),
123
1.32M
            static_cast<__int128>(100LL),
124
1.32M
            static_cast<__int128>(1000LL),
125
1.32M
            static_cast<__int128>(10000LL),
126
1.32M
            static_cast<__int128>(100000LL),
127
1.32M
            static_cast<__int128>(1000000LL),
128
1.32M
            static_cast<__int128>(10000000LL),
129
1.32M
            static_cast<__int128>(100000000LL),
130
1.32M
            static_cast<__int128>(1000000000LL),
131
1.32M
            static_cast<__int128>(10000000000LL),
132
1.32M
            static_cast<__int128>(100000000000LL),
133
1.32M
            static_cast<__int128>(1000000000000LL),
134
1.32M
            static_cast<__int128>(10000000000000LL),
135
1.32M
            static_cast<__int128>(100000000000000LL),
136
1.32M
            static_cast<__int128>(1000000000000000LL),
137
1.32M
            static_cast<__int128>(10000000000000000LL),
138
1.32M
            static_cast<__int128>(100000000000000000LL),
139
1.32M
            static_cast<__int128>(1000000000000000000LL),
140
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10LL,
141
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100LL,
142
1.32M
            static_cast<__int128>(1000000000000000000LL) * 1000LL,
143
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10000LL,
144
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000LL,
145
1.32M
            static_cast<__int128>(1000000000000000000LL) * 1000000LL,
146
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10000000LL,
147
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000LL,
148
1.32M
            static_cast<__int128>(1000000000000000000LL) * 1000000000LL,
149
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10000000000LL,
150
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000LL,
151
1.32M
            static_cast<__int128>(1000000000000000000LL) * 1000000000000LL,
152
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10000000000000LL,
153
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000LL,
154
1.32M
            static_cast<__int128>(1000000000000000000LL) * 1000000000000000LL,
155
1.32M
            static_cast<__int128>(1000000000000000000LL) * 10000000000000000LL,
156
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL,
157
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 10LL,
158
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 100LL,
159
1.32M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 1000LL};
160
1.32M
    return values[x];
161
1.32M
}
162
163
551k
constexpr inline wide::Int256 exp10_i256(int x) {
164
551k
    if (x < 0) {
165
212
        return 0;
166
212
    }
167
551k
    if (x > 76) {
168
110
        return std::numeric_limits<wide::Int256>::max();
169
110
    }
170
171
550k
    constexpr wide::Int256 i10e18 {1000000000000000000LL};
172
550k
    constexpr wide::Int256 values[] = {
173
550k
            static_cast<wide::Int256>(1LL),
174
550k
            static_cast<wide::Int256>(10LL),
175
550k
            static_cast<wide::Int256>(100LL),
176
550k
            static_cast<wide::Int256>(1000LL),
177
550k
            static_cast<wide::Int256>(10000LL),
178
550k
            static_cast<wide::Int256>(100000LL),
179
550k
            static_cast<wide::Int256>(1000000LL),
180
550k
            static_cast<wide::Int256>(10000000LL),
181
550k
            static_cast<wide::Int256>(100000000LL),
182
550k
            static_cast<wide::Int256>(1000000000LL),
183
550k
            static_cast<wide::Int256>(10000000000LL),
184
550k
            static_cast<wide::Int256>(100000000000LL),
185
550k
            static_cast<wide::Int256>(1000000000000LL),
186
550k
            static_cast<wide::Int256>(10000000000000LL),
187
550k
            static_cast<wide::Int256>(100000000000000LL),
188
550k
            static_cast<wide::Int256>(1000000000000000LL),
189
550k
            static_cast<wide::Int256>(10000000000000000LL),
190
550k
            static_cast<wide::Int256>(100000000000000000LL),
191
550k
            i10e18,
192
550k
            i10e18 * 10LL,
193
550k
            i10e18 * 100LL,
194
550k
            i10e18 * 1000LL,
195
550k
            i10e18 * 10000LL,
196
550k
            i10e18 * 100000LL,
197
550k
            i10e18 * 1000000LL,
198
550k
            i10e18 * 10000000LL,
199
550k
            i10e18 * 100000000LL,
200
550k
            i10e18 * 1000000000LL,
201
550k
            i10e18 * 10000000000LL,
202
550k
            i10e18 * 100000000000LL,
203
550k
            i10e18 * 1000000000000LL,
204
550k
            i10e18 * 10000000000000LL,
205
550k
            i10e18 * 100000000000000LL,
206
550k
            i10e18 * 1000000000000000LL,
207
550k
            i10e18 * 10000000000000000LL,
208
550k
            i10e18 * 100000000000000000LL,
209
550k
            i10e18 * 100000000000000000LL * 10LL,
210
550k
            i10e18 * 100000000000000000LL * 100LL,
211
550k
            i10e18 * 100000000000000000LL * 1000LL,
212
550k
            i10e18 * 100000000000000000LL * 10000LL,
213
550k
            i10e18 * 100000000000000000LL * 100000LL,
214
550k
            i10e18 * 100000000000000000LL * 1000000LL,
215
550k
            i10e18 * 100000000000000000LL * 10000000LL,
216
550k
            i10e18 * 100000000000000000LL * 100000000LL,
217
550k
            i10e18 * 100000000000000000LL * 1000000000LL,
218
550k
            i10e18 * 100000000000000000LL * 10000000000LL,
219
550k
            i10e18 * 100000000000000000LL * 100000000000LL,
220
550k
            i10e18 * 100000000000000000LL * 1000000000000LL,
221
550k
            i10e18 * 100000000000000000LL * 10000000000000LL,
222
550k
            i10e18 * 100000000000000000LL * 100000000000000LL,
223
550k
            i10e18 * 100000000000000000LL * 1000000000000000LL,
224
550k
            i10e18 * 100000000000000000LL * 10000000000000000LL,
225
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL,
226
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10LL,
227
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100LL,
228
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000LL,
229
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000LL,
230
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000LL,
231
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000LL,
232
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000LL,
233
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000LL,
234
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000LL,
235
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000LL,
236
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000LL,
237
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000LL,
238
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000LL,
239
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000LL,
240
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000000LL,
241
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000000LL,
242
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL,
243
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10LL,
244
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100LL,
245
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000LL,
246
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10000LL,
247
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100000LL,
248
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000000LL,
249
550k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
250
550k
                    10000000LL,
251
550k
    };
252
550k
    return values[x];
253
551k
}
254
255
1.99k
constexpr inline int max_i32(int digit_count) {
256
1.99k
    if (digit_count < 0) {
257
0
        return 0;
258
0
    }
259
1.99k
    if (digit_count > 9) {
260
0
        return std::numeric_limits<int>::max();
261
0
    }
262
1.99k
    constexpr int values[] = {0, 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999};
263
1.99k
    return values[digit_count];
264
1.99k
}
265
266
2.40k
constexpr inline int64_t max_i64(int digit_count) {
267
2.40k
    if (digit_count < 0) {
268
0
        return 0;
269
0
    }
270
2.40k
    if (digit_count > 18) {
271
0
        return std::numeric_limits<int64_t>::max();
272
0
    }
273
274
2.40k
    constexpr int64_t values[] = {1LL,
275
2.40k
                                  9LL,
276
2.40k
                                  99LL,
277
2.40k
                                  999LL,
278
2.40k
                                  9999LL,
279
2.40k
                                  99999LL,
280
2.40k
                                  999999LL,
281
2.40k
                                  9999999LL,
282
2.40k
                                  99999999LL,
283
2.40k
                                  999999999LL,
284
2.40k
                                  9999999999LL,
285
2.40k
                                  99999999999LL,
286
2.40k
                                  999999999999LL,
287
2.40k
                                  9999999999999LL,
288
2.40k
                                  99999999999999LL,
289
2.40k
                                  999999999999999LL,
290
2.40k
                                  9999999999999999LL,
291
2.40k
                                  99999999999999999LL,
292
2.40k
                                  999999999999999999LL};
293
2.40k
    return values[digit_count];
294
2.40k
}
295
296
148
constexpr inline int count_digits_fast(int64_t n) {
297
148
    uint64_t abs_n = (n < 0 ? uint64_t(-n) : uint64_t(n));
298
148
    if (abs_n == 0) [[unlikely]] {
299
6
        return 1;
300
6
    }
301
302
142
    int bits = 64 - __builtin_clzll(abs_n);
303
142
    int d = (bits * 1233) >> 12;
304
305
142
    if (abs_n < int_exp10(d)) {
306
19
        --d;
307
123
    } else if (abs_n >= int_exp10(d + 1)) {
308
0
        ++d;
309
0
    }
310
311
142
    return d + 1;
312
148
}
313
314
2.09k
constexpr inline __int128 max_i128(int digit_count) {
315
2.09k
    DCHECK(digit_count > 0);
316
2.09k
    constexpr __int128 values[] = {
317
2.09k
            static_cast<__int128>(0LL),
318
2.09k
            static_cast<__int128>(9LL),
319
2.09k
            static_cast<__int128>(99LL),
320
2.09k
            static_cast<__int128>(999LL),
321
2.09k
            static_cast<__int128>(9999LL),
322
2.09k
            static_cast<__int128>(99999LL),
323
2.09k
            static_cast<__int128>(999999LL),
324
2.09k
            static_cast<__int128>(9999999LL),
325
2.09k
            static_cast<__int128>(99999999LL),
326
2.09k
            static_cast<__int128>(999999999LL),
327
2.09k
            static_cast<__int128>(9999999999LL),
328
2.09k
            static_cast<__int128>(99999999999LL),
329
2.09k
            static_cast<__int128>(999999999999LL),
330
2.09k
            static_cast<__int128>(9999999999999LL),
331
2.09k
            static_cast<__int128>(99999999999999LL),
332
2.09k
            static_cast<__int128>(999999999999999LL),
333
2.09k
            static_cast<__int128>(9999999999999999LL),
334
2.09k
            static_cast<__int128>(99999999999999999LL),
335
2.09k
            static_cast<__int128>(999999999999999999LL),
336
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10LL - 1,
337
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100LL - 1,
338
2.09k
            static_cast<__int128>(1000000000000000000LL) * 1000LL - 1,
339
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10000LL - 1,
340
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000LL - 1,
341
2.09k
            static_cast<__int128>(1000000000000000000LL) * 1000000LL - 1,
342
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10000000LL - 1,
343
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000LL - 1,
344
2.09k
            static_cast<__int128>(1000000000000000000LL) * 1000000000LL - 1,
345
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10000000000LL - 1,
346
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000LL - 1,
347
2.09k
            static_cast<__int128>(1000000000000000000LL) * 1000000000000LL - 1,
348
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10000000000000LL - 1,
349
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000LL - 1,
350
2.09k
            static_cast<__int128>(1000000000000000000LL) * 1000000000000000LL - 1,
351
2.09k
            static_cast<__int128>(1000000000000000000LL) * 10000000000000000LL - 1,
352
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL - 1,
353
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 10LL - 1,
354
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 100LL - 1,
355
2.09k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 1000LL - 1};
356
2.09k
    return values[digit_count];
357
2.09k
}
358
359
1.73k
constexpr inline wide::Int256 max_i256(int digit_count) {
360
1.73k
    if (digit_count < 0) {
361
0
        return 0;
362
0
    }
363
1.73k
    if (digit_count > 76) {
364
0
        return std::numeric_limits<wide::Int256>::max();
365
0
    }
366
367
1.73k
    constexpr wide::Int256 i10e18 {1000000000000000000LL};
368
1.73k
    constexpr wide::Int256 values[] = {
369
1.73k
            static_cast<wide::Int256>(0LL),
370
1.73k
            static_cast<wide::Int256>(9LL),
371
1.73k
            static_cast<wide::Int256>(99LL),
372
1.73k
            static_cast<wide::Int256>(999LL),
373
1.73k
            static_cast<wide::Int256>(9999LL),
374
1.73k
            static_cast<wide::Int256>(99999LL),
375
1.73k
            static_cast<wide::Int256>(999999LL),
376
1.73k
            static_cast<wide::Int256>(9999999LL),
377
1.73k
            static_cast<wide::Int256>(99999999LL),
378
1.73k
            static_cast<wide::Int256>(999999999LL),
379
1.73k
            static_cast<wide::Int256>(9999999999LL),
380
1.73k
            static_cast<wide::Int256>(99999999999LL),
381
1.73k
            static_cast<wide::Int256>(999999999999LL),
382
1.73k
            static_cast<wide::Int256>(9999999999999LL),
383
1.73k
            static_cast<wide::Int256>(99999999999999LL),
384
1.73k
            static_cast<wide::Int256>(999999999999999LL),
385
1.73k
            static_cast<wide::Int256>(9999999999999999LL),
386
1.73k
            static_cast<wide::Int256>(99999999999999999LL),
387
1.73k
            i10e18 - 1,
388
1.73k
            i10e18 * 10LL - 1,
389
1.73k
            i10e18 * 100LL - 1,
390
1.73k
            i10e18 * 1000LL - 1,
391
1.73k
            i10e18 * 10000LL - 1,
392
1.73k
            i10e18 * 100000LL - 1,
393
1.73k
            i10e18 * 1000000LL - 1,
394
1.73k
            i10e18 * 10000000LL - 1,
395
1.73k
            i10e18 * 100000000LL - 1,
396
1.73k
            i10e18 * 1000000000LL - 1,
397
1.73k
            i10e18 * 10000000000LL - 1,
398
1.73k
            i10e18 * 100000000000LL - 1,
399
1.73k
            i10e18 * 1000000000000LL - 1,
400
1.73k
            i10e18 * 10000000000000LL - 1,
401
1.73k
            i10e18 * 100000000000000LL - 1,
402
1.73k
            i10e18 * 1000000000000000LL - 1,
403
1.73k
            i10e18 * 10000000000000000LL - 1,
404
1.73k
            i10e18 * 100000000000000000LL - 1,
405
1.73k
            i10e18 * 100000000000000000LL * 10LL - 1,
406
1.73k
            i10e18 * 100000000000000000LL * 100LL - 1,
407
1.73k
            i10e18 * 100000000000000000LL * 1000LL - 1,
408
1.73k
            i10e18 * 100000000000000000LL * 10000LL - 1,
409
1.73k
            i10e18 * 100000000000000000LL * 100000LL - 1,
410
1.73k
            i10e18 * 100000000000000000LL * 1000000LL - 1,
411
1.73k
            i10e18 * 100000000000000000LL * 10000000LL - 1,
412
1.73k
            i10e18 * 100000000000000000LL * 100000000LL - 1,
413
1.73k
            i10e18 * 100000000000000000LL * 1000000000LL - 1,
414
1.73k
            i10e18 * 100000000000000000LL * 10000000000LL - 1,
415
1.73k
            i10e18 * 100000000000000000LL * 100000000000LL - 1,
416
1.73k
            i10e18 * 100000000000000000LL * 1000000000000LL - 1,
417
1.73k
            i10e18 * 100000000000000000LL * 10000000000000LL - 1,
418
1.73k
            i10e18 * 100000000000000000LL * 100000000000000LL - 1,
419
1.73k
            i10e18 * 100000000000000000LL * 1000000000000000LL - 1,
420
1.73k
            i10e18 * 100000000000000000LL * 10000000000000000LL - 1,
421
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL - 1,
422
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10LL - 1,
423
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100LL - 1,
424
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000LL - 1,
425
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000LL - 1,
426
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000LL - 1,
427
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000LL - 1,
428
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000LL - 1,
429
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000LL - 1,
430
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000LL - 1,
431
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000LL - 1,
432
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000LL - 1,
433
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000LL - 1,
434
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000LL - 1,
435
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000LL - 1,
436
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000000LL - 1,
437
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000000LL - 1,
438
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL - 1,
439
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10LL - 1,
440
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100LL - 1,
441
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000LL -
442
1.73k
                    1,
443
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10000LL -
444
1.73k
                    1,
445
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100000LL -
446
1.73k
                    1,
447
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
448
1.73k
                            1000000LL -
449
1.73k
                    1,
450
1.73k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
451
1.73k
                            10000000LL -
452
1.73k
                    1,
453
1.73k
    };
454
1.73k
    return values[digit_count];
455
1.73k
}
456
} // namespace common