Coverage Report

Created: 2026-07-31 03:50

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
9.23M
constexpr T get_exp_helper(std::size_t x, std::index_sequence<I...>) {
45
9.23M
    return exp_table<T, v, I...>[x];
46
9.23M
}
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
9.23M
constexpr T get_exp(std::size_t x) {
51
9.23M
    return get_exp_helper<T, v>(x, std::make_index_sequence<N> {});
52
9.23M
}
53
54
} // namespace exp_details
55
56
9.23M
inline uint64_t int_exp10(int x) {
57
9.23M
    if (x < 0) {
58
0
        return 0;
59
0
    }
60
9.23M
    if (x > 19) {
61
2
        return std::numeric_limits<uint64_t>::max();
62
2
    }
63
64
9.23M
    return exp_details::get_exp<uint64_t, 10, 20>(x);
65
9.23M
}
66
67
namespace common {
68
69
12.5M
constexpr inline int exp10_i32(int x) {
70
12.5M
    if (x < 0) {
71
218
        return 0;
72
218
    }
73
12.5M
    if (x > 9) {
74
838
        return std::numeric_limits<int>::max();
75
838
    }
76
77
12.5M
    constexpr int values[] = {1,      10,      100,      1000,      10000,
78
12.5M
                              100000, 1000000, 10000000, 100000000, 1000000000};
79
12.5M
    return values[x];
80
12.5M
}
81
82
102M
constexpr inline int64_t exp10_i64(int x) {
83
102M
    if (x < 0) {
84
212
        return 0;
85
212
    }
86
102M
    if (x > 18) {
87
142
        return std::numeric_limits<int64_t>::max();
88
142
    }
89
90
102M
    constexpr int64_t values[] = {1LL,
91
102M
                                  10LL,
92
102M
                                  100LL,
93
102M
                                  1000LL,
94
102M
                                  10000LL,
95
102M
                                  100000LL,
96
102M
                                  1000000LL,
97
102M
                                  10000000LL,
98
102M
                                  100000000LL,
99
102M
                                  1000000000LL,
100
102M
                                  10000000000LL,
101
102M
                                  100000000000LL,
102
102M
                                  1000000000000LL,
103
102M
                                  10000000000000LL,
104
102M
                                  100000000000000LL,
105
102M
                                  1000000000000000LL,
106
102M
                                  10000000000000000LL,
107
102M
                                  100000000000000000LL,
108
102M
                                  1000000000000000000LL};
109
102M
    return values[x];
110
102M
}
111
112
41.1M
constexpr inline __int128 exp10_i128(int x) {
113
41.1M
    if (x < 0) {
114
288
        return 0;
115
288
    }
116
41.1M
    if (x > 38) {
117
77
        return std::numeric_limits<__int128>::max();
118
77
    }
119
120
41.1M
    constexpr __int128 values[] = {
121
41.1M
            static_cast<__int128>(1LL),
122
41.1M
            static_cast<__int128>(10LL),
123
41.1M
            static_cast<__int128>(100LL),
124
41.1M
            static_cast<__int128>(1000LL),
125
41.1M
            static_cast<__int128>(10000LL),
126
41.1M
            static_cast<__int128>(100000LL),
127
41.1M
            static_cast<__int128>(1000000LL),
128
41.1M
            static_cast<__int128>(10000000LL),
129
41.1M
            static_cast<__int128>(100000000LL),
130
41.1M
            static_cast<__int128>(1000000000LL),
131
41.1M
            static_cast<__int128>(10000000000LL),
132
41.1M
            static_cast<__int128>(100000000000LL),
133
41.1M
            static_cast<__int128>(1000000000000LL),
134
41.1M
            static_cast<__int128>(10000000000000LL),
135
41.1M
            static_cast<__int128>(100000000000000LL),
136
41.1M
            static_cast<__int128>(1000000000000000LL),
137
41.1M
            static_cast<__int128>(10000000000000000LL),
138
41.1M
            static_cast<__int128>(100000000000000000LL),
139
41.1M
            static_cast<__int128>(1000000000000000000LL),
140
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10LL,
141
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100LL,
142
41.1M
            static_cast<__int128>(1000000000000000000LL) * 1000LL,
143
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10000LL,
144
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000LL,
145
41.1M
            static_cast<__int128>(1000000000000000000LL) * 1000000LL,
146
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10000000LL,
147
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000LL,
148
41.1M
            static_cast<__int128>(1000000000000000000LL) * 1000000000LL,
149
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10000000000LL,
150
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000LL,
151
41.1M
            static_cast<__int128>(1000000000000000000LL) * 1000000000000LL,
152
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10000000000000LL,
153
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000LL,
154
41.1M
            static_cast<__int128>(1000000000000000000LL) * 1000000000000000LL,
155
41.1M
            static_cast<__int128>(1000000000000000000LL) * 10000000000000000LL,
156
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL,
157
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 10LL,
158
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 100LL,
159
41.1M
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 1000LL};
160
41.1M
    return values[x];
161
41.1M
}
162
163
638k
constexpr inline wide::Int256 exp10_i256(int x) {
164
638k
    if (x < 0) {
165
212
        return 0;
166
212
    }
167
638k
    if (x > 76) {
168
126
        return std::numeric_limits<wide::Int256>::max();
169
126
    }
170
171
638k
    constexpr wide::Int256 i10e18 {1000000000000000000LL};
172
638k
    constexpr wide::Int256 values[] = {
173
638k
            static_cast<wide::Int256>(1LL),
174
638k
            static_cast<wide::Int256>(10LL),
175
638k
            static_cast<wide::Int256>(100LL),
176
638k
            static_cast<wide::Int256>(1000LL),
177
638k
            static_cast<wide::Int256>(10000LL),
178
638k
            static_cast<wide::Int256>(100000LL),
179
638k
            static_cast<wide::Int256>(1000000LL),
180
638k
            static_cast<wide::Int256>(10000000LL),
181
638k
            static_cast<wide::Int256>(100000000LL),
182
638k
            static_cast<wide::Int256>(1000000000LL),
183
638k
            static_cast<wide::Int256>(10000000000LL),
184
638k
            static_cast<wide::Int256>(100000000000LL),
185
638k
            static_cast<wide::Int256>(1000000000000LL),
186
638k
            static_cast<wide::Int256>(10000000000000LL),
187
638k
            static_cast<wide::Int256>(100000000000000LL),
188
638k
            static_cast<wide::Int256>(1000000000000000LL),
189
638k
            static_cast<wide::Int256>(10000000000000000LL),
190
638k
            static_cast<wide::Int256>(100000000000000000LL),
191
638k
            i10e18,
192
638k
            i10e18 * 10LL,
193
638k
            i10e18 * 100LL,
194
638k
            i10e18 * 1000LL,
195
638k
            i10e18 * 10000LL,
196
638k
            i10e18 * 100000LL,
197
638k
            i10e18 * 1000000LL,
198
638k
            i10e18 * 10000000LL,
199
638k
            i10e18 * 100000000LL,
200
638k
            i10e18 * 1000000000LL,
201
638k
            i10e18 * 10000000000LL,
202
638k
            i10e18 * 100000000000LL,
203
638k
            i10e18 * 1000000000000LL,
204
638k
            i10e18 * 10000000000000LL,
205
638k
            i10e18 * 100000000000000LL,
206
638k
            i10e18 * 1000000000000000LL,
207
638k
            i10e18 * 10000000000000000LL,
208
638k
            i10e18 * 100000000000000000LL,
209
638k
            i10e18 * 100000000000000000LL * 10LL,
210
638k
            i10e18 * 100000000000000000LL * 100LL,
211
638k
            i10e18 * 100000000000000000LL * 1000LL,
212
638k
            i10e18 * 100000000000000000LL * 10000LL,
213
638k
            i10e18 * 100000000000000000LL * 100000LL,
214
638k
            i10e18 * 100000000000000000LL * 1000000LL,
215
638k
            i10e18 * 100000000000000000LL * 10000000LL,
216
638k
            i10e18 * 100000000000000000LL * 100000000LL,
217
638k
            i10e18 * 100000000000000000LL * 1000000000LL,
218
638k
            i10e18 * 100000000000000000LL * 10000000000LL,
219
638k
            i10e18 * 100000000000000000LL * 100000000000LL,
220
638k
            i10e18 * 100000000000000000LL * 1000000000000LL,
221
638k
            i10e18 * 100000000000000000LL * 10000000000000LL,
222
638k
            i10e18 * 100000000000000000LL * 100000000000000LL,
223
638k
            i10e18 * 100000000000000000LL * 1000000000000000LL,
224
638k
            i10e18 * 100000000000000000LL * 10000000000000000LL,
225
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL,
226
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10LL,
227
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100LL,
228
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000LL,
229
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000LL,
230
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000LL,
231
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000LL,
232
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000LL,
233
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000LL,
234
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000LL,
235
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000LL,
236
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000LL,
237
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000LL,
238
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000LL,
239
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000LL,
240
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000000LL,
241
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000000LL,
242
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL,
243
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10LL,
244
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100LL,
245
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000LL,
246
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10000LL,
247
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100000LL,
248
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000000LL,
249
638k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
250
638k
                    10000000LL,
251
638k
    };
252
638k
    return values[x];
253
638k
}
254
255
9.35k
constexpr inline int max_i32(int digit_count) {
256
9.35k
    if (digit_count < 0) {
257
0
        return 0;
258
0
    }
259
9.35k
    if (digit_count > 9) {
260
0
        return std::numeric_limits<int>::max();
261
0
    }
262
9.35k
    constexpr int values[] = {0, 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999};
263
9.35k
    return values[digit_count];
264
9.35k
}
265
266
39.0k
constexpr inline int64_t max_i64(int digit_count) {
267
39.0k
    if (digit_count < 0) {
268
0
        return 0;
269
0
    }
270
39.0k
    if (digit_count > 18) {
271
0
        return std::numeric_limits<int64_t>::max();
272
0
    }
273
274
39.0k
    constexpr int64_t values[] = {1LL,
275
39.0k
                                  9LL,
276
39.0k
                                  99LL,
277
39.0k
                                  999LL,
278
39.0k
                                  9999LL,
279
39.0k
                                  99999LL,
280
39.0k
                                  999999LL,
281
39.0k
                                  9999999LL,
282
39.0k
                                  99999999LL,
283
39.0k
                                  999999999LL,
284
39.0k
                                  9999999999LL,
285
39.0k
                                  99999999999LL,
286
39.0k
                                  999999999999LL,
287
39.0k
                                  9999999999999LL,
288
39.0k
                                  99999999999999LL,
289
39.0k
                                  999999999999999LL,
290
39.0k
                                  9999999999999999LL,
291
39.0k
                                  99999999999999999LL,
292
39.0k
                                  999999999999999999LL};
293
39.0k
    return values[digit_count];
294
39.0k
}
295
296
403
constexpr inline int count_digits_fast(int64_t n) {
297
403
    uint64_t abs_n = (n < 0 ? uint64_t(-n) : uint64_t(n));
298
403
    if (abs_n == 0) [[unlikely]] {
299
39
        return 1;
300
39
    }
301
302
364
    int bits = 64 - __builtin_clzll(abs_n);
303
364
    int d = (bits * 1233) >> 12;
304
305
364
    if (abs_n < int_exp10(d)) {
306
40
        --d;
307
324
    } else if (abs_n >= int_exp10(d + 1)) {
308
0
        ++d;
309
0
    }
310
311
364
    return d + 1;
312
403
}
313
314
31.3k
constexpr inline __int128 max_i128(int digit_count) {
315
31.3k
    DCHECK(digit_count > 0);
316
31.3k
    constexpr __int128 values[] = {
317
31.3k
            static_cast<__int128>(0LL),
318
31.3k
            static_cast<__int128>(9LL),
319
31.3k
            static_cast<__int128>(99LL),
320
31.3k
            static_cast<__int128>(999LL),
321
31.3k
            static_cast<__int128>(9999LL),
322
31.3k
            static_cast<__int128>(99999LL),
323
31.3k
            static_cast<__int128>(999999LL),
324
31.3k
            static_cast<__int128>(9999999LL),
325
31.3k
            static_cast<__int128>(99999999LL),
326
31.3k
            static_cast<__int128>(999999999LL),
327
31.3k
            static_cast<__int128>(9999999999LL),
328
31.3k
            static_cast<__int128>(99999999999LL),
329
31.3k
            static_cast<__int128>(999999999999LL),
330
31.3k
            static_cast<__int128>(9999999999999LL),
331
31.3k
            static_cast<__int128>(99999999999999LL),
332
31.3k
            static_cast<__int128>(999999999999999LL),
333
31.3k
            static_cast<__int128>(9999999999999999LL),
334
31.3k
            static_cast<__int128>(99999999999999999LL),
335
31.3k
            static_cast<__int128>(999999999999999999LL),
336
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10LL - 1,
337
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100LL - 1,
338
31.3k
            static_cast<__int128>(1000000000000000000LL) * 1000LL - 1,
339
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10000LL - 1,
340
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000LL - 1,
341
31.3k
            static_cast<__int128>(1000000000000000000LL) * 1000000LL - 1,
342
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10000000LL - 1,
343
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000LL - 1,
344
31.3k
            static_cast<__int128>(1000000000000000000LL) * 1000000000LL - 1,
345
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10000000000LL - 1,
346
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000LL - 1,
347
31.3k
            static_cast<__int128>(1000000000000000000LL) * 1000000000000LL - 1,
348
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10000000000000LL - 1,
349
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000LL - 1,
350
31.3k
            static_cast<__int128>(1000000000000000000LL) * 1000000000000000LL - 1,
351
31.3k
            static_cast<__int128>(1000000000000000000LL) * 10000000000000000LL - 1,
352
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL - 1,
353
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 10LL - 1,
354
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 100LL - 1,
355
31.3k
            static_cast<__int128>(1000000000000000000LL) * 100000000000000000LL * 1000LL - 1};
356
31.3k
    return values[digit_count];
357
31.3k
}
358
359
5.61k
constexpr inline wide::Int256 max_i256(int digit_count) {
360
5.61k
    if (digit_count < 0) {
361
0
        return 0;
362
0
    }
363
5.61k
    if (digit_count > 76) {
364
0
        return std::numeric_limits<wide::Int256>::max();
365
0
    }
366
367
5.61k
    constexpr wide::Int256 i10e18 {1000000000000000000LL};
368
5.61k
    constexpr wide::Int256 values[] = {
369
5.61k
            static_cast<wide::Int256>(0LL),
370
5.61k
            static_cast<wide::Int256>(9LL),
371
5.61k
            static_cast<wide::Int256>(99LL),
372
5.61k
            static_cast<wide::Int256>(999LL),
373
5.61k
            static_cast<wide::Int256>(9999LL),
374
5.61k
            static_cast<wide::Int256>(99999LL),
375
5.61k
            static_cast<wide::Int256>(999999LL),
376
5.61k
            static_cast<wide::Int256>(9999999LL),
377
5.61k
            static_cast<wide::Int256>(99999999LL),
378
5.61k
            static_cast<wide::Int256>(999999999LL),
379
5.61k
            static_cast<wide::Int256>(9999999999LL),
380
5.61k
            static_cast<wide::Int256>(99999999999LL),
381
5.61k
            static_cast<wide::Int256>(999999999999LL),
382
5.61k
            static_cast<wide::Int256>(9999999999999LL),
383
5.61k
            static_cast<wide::Int256>(99999999999999LL),
384
5.61k
            static_cast<wide::Int256>(999999999999999LL),
385
5.61k
            static_cast<wide::Int256>(9999999999999999LL),
386
5.61k
            static_cast<wide::Int256>(99999999999999999LL),
387
5.61k
            i10e18 - 1,
388
5.61k
            i10e18 * 10LL - 1,
389
5.61k
            i10e18 * 100LL - 1,
390
5.61k
            i10e18 * 1000LL - 1,
391
5.61k
            i10e18 * 10000LL - 1,
392
5.61k
            i10e18 * 100000LL - 1,
393
5.61k
            i10e18 * 1000000LL - 1,
394
5.61k
            i10e18 * 10000000LL - 1,
395
5.61k
            i10e18 * 100000000LL - 1,
396
5.61k
            i10e18 * 1000000000LL - 1,
397
5.61k
            i10e18 * 10000000000LL - 1,
398
5.61k
            i10e18 * 100000000000LL - 1,
399
5.61k
            i10e18 * 1000000000000LL - 1,
400
5.61k
            i10e18 * 10000000000000LL - 1,
401
5.61k
            i10e18 * 100000000000000LL - 1,
402
5.61k
            i10e18 * 1000000000000000LL - 1,
403
5.61k
            i10e18 * 10000000000000000LL - 1,
404
5.61k
            i10e18 * 100000000000000000LL - 1,
405
5.61k
            i10e18 * 100000000000000000LL * 10LL - 1,
406
5.61k
            i10e18 * 100000000000000000LL * 100LL - 1,
407
5.61k
            i10e18 * 100000000000000000LL * 1000LL - 1,
408
5.61k
            i10e18 * 100000000000000000LL * 10000LL - 1,
409
5.61k
            i10e18 * 100000000000000000LL * 100000LL - 1,
410
5.61k
            i10e18 * 100000000000000000LL * 1000000LL - 1,
411
5.61k
            i10e18 * 100000000000000000LL * 10000000LL - 1,
412
5.61k
            i10e18 * 100000000000000000LL * 100000000LL - 1,
413
5.61k
            i10e18 * 100000000000000000LL * 1000000000LL - 1,
414
5.61k
            i10e18 * 100000000000000000LL * 10000000000LL - 1,
415
5.61k
            i10e18 * 100000000000000000LL * 100000000000LL - 1,
416
5.61k
            i10e18 * 100000000000000000LL * 1000000000000LL - 1,
417
5.61k
            i10e18 * 100000000000000000LL * 10000000000000LL - 1,
418
5.61k
            i10e18 * 100000000000000000LL * 100000000000000LL - 1,
419
5.61k
            i10e18 * 100000000000000000LL * 1000000000000000LL - 1,
420
5.61k
            i10e18 * 100000000000000000LL * 10000000000000000LL - 1,
421
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL - 1,
422
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10LL - 1,
423
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100LL - 1,
424
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000LL - 1,
425
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000LL - 1,
426
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000LL - 1,
427
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000LL - 1,
428
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000LL - 1,
429
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000LL - 1,
430
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000LL - 1,
431
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000LL - 1,
432
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000LL - 1,
433
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000LL - 1,
434
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000LL - 1,
435
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000LL - 1,
436
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 1000000000000000LL - 1,
437
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 10000000000000000LL - 1,
438
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL - 1,
439
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10LL - 1,
440
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100LL - 1,
441
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 1000LL -
442
5.61k
                    1,
443
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 10000LL -
444
5.61k
                    1,
445
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL * 100000LL -
446
5.61k
                    1,
447
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
448
5.61k
                            1000000LL -
449
5.61k
                    1,
450
5.61k
            i10e18 * 100000000000000000LL * 100000000000000000LL * 100000000000000000LL *
451
5.61k
                            10000000LL -
452
5.61k
                    1,
453
5.61k
    };
454
5.61k
    return values[digit_count];
455
5.61k
}
456
} // namespace common