Kind Pure package
Name v1
Namespace gnoswap / uint256
Exported functions n/a — not supported for pure packages by the node (vm/qfuncs)
Module gno.land/p/gnoswap/uint256/v1
gno 0.9 conversion.gno gno
⧉
1 // conversions contains methods for converting Uint instances to other types and vice versa. 2 // This includes conversions to and from basic types such as uint64 and int32, as well as string representations 3 // and byte slices. Additionally, it covers marshaling and unmarshaling for JSON and other text formats. 4 package uint256 5 6 import ( 7 not supported for pure packages by the node (vm/qfuncs)
Signatures reconstructed verbatim from vm/qfuncs — interface params keep their inline definitions.
"encoding/binary"
8 "strconv"
9 )
10
11 // Uint64 returns the lower 64 bits of z as a uint64.
12 //
13 // Returns:
14 // - value: the low 64 bits of z
15 func (z *Uint) Uint64() uint64 {
16 return z[ 0 ]
17 }
18
19 // Int64 returns the lower 64 bits of z as an int64.
20 //
21 // Returns:
22 // - value: the low 64 bits of z interpreted as int64
23 func (z *Uint) Int64() int64 {
24 return int64 (z.Uint64())
25 }
26
27 // Uint64WithOverflow returns the lower 64 bits of z and true if overflow occurred.
28 //
29 // Returns:
30 // - value: the low 64 bits of z
31 // - overflow: true when any upper 192 bits are non-zero
32 func (z *Uint) Uint64WithOverflow() ( uint64 , bool ) {
33 return z[ 0 ], (z[ 1 ] | z[ 2 ] | z[ 3 ]) != 0
34 }
35
36 // SetUint64 sets z to the value of x and returns z.
37 //
38 // Parameters:
39 // - x: the uint64 value assigned to z
40 //
41 // Returns:
42 // - result: z after setting it to x
43 func (z *Uint) SetUint64(x uint64 ) *Uint {
44 z[ 3 ], z[ 2 ], z[ 1 ], z[ 0 ] = 0 , 0 , 0 , x
45 return z
46 }
47
48 // IsUint64 reports whether z can be represented as a uint64.
49 //
50 // Returns:
51 // - fits: true when z is representable in 64 bits
52 func (z *Uint) IsUint64() bool {
53 return (z[ 1 ] | z[ 2 ] | z[ 3 ]) == 0
54 }
55
56 // Dec returns the decimal representation of z.
57 //
58 // Returns:
59 // - decimal: the base-10 representation of z
60 func (z *Uint) Dec() string {
61 if z.IsZero() {
62 return "0"
63 }
64 if z.IsUint64() {
65 return strconv.FormatUint(z.Uint64(), 10 )
66 }
67
68 // The max uint64 value being 18446744073709551615, the largest
69 // power-of-ten below that is 10000000000000000000.
70 // When we do a DivMod using that number, the remainder that we
71 // get back is the lower part of the output.
72 //
73 // The ascii-output of remainder will never exceed 19 bytes (since it will be
74 // below 10000000000000000000).
75 //
76 // Algorithm example using 100 as divisor
77 //
78 // 12345 % 100 = 45 (rem)
79 // 12345 / 100 = 123 (quo)
80 // -> output '45', continue iterate on 123
81 var (
82 // out is 98 bytes long: 78 (max size of a string without leading zeroes,
83 // plus slack so we can copy 19 bytes every iteration).
84 // We init it with zeroes, because when strconv appends the ascii representations,
85 // it will omit leading zeroes.
86 out [ 98 ] byte
87 divisor Uint
88 y = *z // copy z to avoid modifying it
89 pos = len(out) // position to write to
90 buf [ 19 ] byte // buffer to write uint64:s to
91 bufSlice [] byte = buf[: 0 ] // slice for strconv.AppendUint
92 )
93
94 // Initialize out array with '0's
95 for i := range out {
96 out[i] = '0'
97 }
98
99 // Set divisor to 10^19
100 divisor.SetUint64( 10000000000000000000 )
101
102 for {
103 // Obtain Q and R for divisor
104 var quot Uint
105 rem := udivrem(quot[:], y[:], &divisor)
106 y = quot // Set Q for next loop
107 // Convert the R to ascii representation
108 bufSlice = strconv.AppendUint(bufSlice[: 0 ], rem.Uint64(), 10 )
109 // Copy in the ascii digits
110 copy(out[pos-len(bufSlice):], bufSlice)
111 if y.IsZero() {
112 break
113 }
114 // Move 19 digits left
115 pos -= 19
116 }
117 // skip leading zeroes by only using the 'used size' of bufSlice
118 return string (out[pos-len(bufSlice):])
119 }
120
121 // ToString returns the decimal string representation of z.
122 // Returns an empty string if z is nil. This method doesn't exist in holiman's uint256.
123 //
124 // Returns:
125 // - decimal: z in base 10, or an empty string when z is nil
126 func (z *Uint) ToString() string {
127 if z == nil {
128 return ""
129 }
130
131 return z.Dec()
132 }
133
134 // SetBytes interprets buf as a big-endian unsigned integer and sets z to that value.
135 // If buf is larger than 32 bytes, uses only the last 32 bytes. Returns z.
136 //
137 // Parameters:
138 // - buf: the big-endian byte sequence; if longer than 32 bytes, only its final 32 bytes are used
139 //
140 // Returns:
141 // - result: z after decoding the selected big-endian bytes
142 func (z *Uint) SetBytes(buf [] byte ) *Uint {
143 switch l := len(buf); l {
144 case 0 :
145 z.Clear()
146 case 1 :
147 z.SetBytes1(buf)
148 case 2 :
149 z.SetBytes2(buf)
150 case 3 :
151 z.SetBytes3(buf)
152 case 4 :
153 z.SetBytes4(buf)
154 case 5 :
155 z.SetBytes5(buf)
156 case 6 :
157 z.SetBytes6(buf)
158 case 7 :
159 z.SetBytes7(buf)
160 case 8 :
161 z.SetBytes8(buf)
162 case 9 :
163 z.SetBytes9(buf)
164 case 10 :
165 z.SetBytes10(buf)
166 case 11 :
167 z.SetBytes11(buf)
168 case 12 :
169 z.SetBytes12(buf)
170 case 13 :
171 z.SetBytes13(buf)
172 case 14 :
173 z.SetBytes14(buf)
174 case 15 :
175 z.SetBytes15(buf)
176 case 16 :
177 z.SetBytes16(buf)
178 case 17 :
179 z.SetBytes17(buf)
180 case 18 :
181 z.SetBytes18(buf)
182 case 19 :
183 z.SetBytes19(buf)
184 case 20 :
185 z.SetBytes20(buf)
186 case 21 :
187 z.SetBytes21(buf)
188 case 22 :
189 z.SetBytes22(buf)
190 case 23 :
191 z.SetBytes23(buf)
192 case 24 :
193 z.SetBytes24(buf)
194 case 25 :
195 z.SetBytes25(buf)
196 case 26 :
197 z.SetBytes26(buf)
198 case 27 :
199 z.SetBytes27(buf)
200 case 28 :
201 z.SetBytes28(buf)
202 case 29 :
203 z.SetBytes29(buf)
204 case 30 :
205 z.SetBytes30(buf)
206 case 31 :
207 z.SetBytes31(buf)
208 default :
209 z.SetBytes32(buf[l- 32 :])
210 }
211 return z
212 }
213
214 // SetBytes1 sets z from a 1-byte big-endian slice and returns z.
215 // Panics if input is shorter than 1 byte.
216 //
217 // Parameters:
218 // - in: the first byte is decoded in big-endian order; it must be present
219 //
220 // Returns:
221 // - result: z after decoding the first byte of in
222 func (z *Uint) SetBytes1(in [] byte ) *Uint {
223 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
224 z[ 0 ] = uint64 (in[ 0 ])
225 return z
226 }
227
228 // SetBytes2 sets z from a 2-byte big-endian slice and returns z.
229 // Panics if input is shorter than 2 bytes.
230 //
231 // Parameters:
232 // - in: the byte sequence whose first 2 bytes are decoded in big-endian order; it must contain at least 2 bytes
233 //
234 // Returns:
235 // - result: z after decoding the first 2 bytes of in in big-endian order
236 func (z *Uint) SetBytes2(in [] byte ) *Uint {
237 _ = in[ 1 ] // bounds check hint to compiler; see golang.org/issue/14808
238 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
239 z[ 0 ] = uint64 (binary.BigEndian.Uint16(in[ 0 : 2 ]))
240 return z
241 }
242
243 // SetBytes3 sets z from a 3-byte big-endian slice and returns z.
244 // Panics if input is shorter than 3 bytes.
245 //
246 // Parameters:
247 // - in: the byte sequence whose first 3 bytes are decoded in big-endian order; it must contain at least 3 bytes
248 //
249 // Returns:
250 // - result: z after decoding the first 3 bytes of in in big-endian order
251 func (z *Uint) SetBytes3(in [] byte ) *Uint {
252 _ = in[ 2 ] // bounds check hint to compiler; see golang.org/issue/14808
253 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
254 z[ 0 ] = uint64 (binary.BigEndian.Uint16(in[ 1 : 3 ])) | uint64 (in[ 0 ])<< 16
255 return z
256 }
257
258 // SetBytes4 sets z from a 4-byte big-endian slice and returns z.
259 // Panics if input is shorter than 4 bytes.
260 //
261 // Parameters:
262 // - in: the byte sequence whose first 4 bytes are decoded in big-endian order; it must contain at least 4 bytes
263 //
264 // Returns:
265 // - result: z after decoding the first 4 bytes of in in big-endian order
266 func (z *Uint) SetBytes4(in [] byte ) *Uint {
267 _ = in[ 3 ] // bounds check hint to compiler; see golang.org/issue/14808
268 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
269 z[ 0 ] = uint64 (binary.BigEndian.Uint32(in[ 0 : 4 ]))
270 return z
271 }
272
273 // SetBytes5 sets z from a 5-byte big-endian slice and returns z.
274 // Panics if input is shorter than 5 bytes.
275 //
276 // Parameters:
277 // - in: the byte sequence whose first 5 bytes are decoded in big-endian order; it must contain at least 5 bytes
278 //
279 // Returns:
280 // - result: z after decoding the first 5 bytes of in in big-endian order
281 func (z *Uint) SetBytes5(in [] byte ) *Uint {
282 _ = in[ 4 ] // bounds check hint to compiler; see golang.org/issue/14808
283 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
284 z[ 0 ] = bigEndianUint40(in[ 0 : 5 ])
285 return z
286 }
287
288 // SetBytes6 sets z from a 6-byte big-endian slice and returns z.
289 // Panics if input is shorter than 6 bytes.
290 //
291 // Parameters:
292 // - in: the byte sequence whose first 6 bytes are decoded in big-endian order; it must contain at least 6 bytes
293 //
294 // Returns:
295 // - result: z after decoding the first 6 bytes of in in big-endian order
296 func (z *Uint) SetBytes6(in [] byte ) *Uint {
297 _ = in[ 5 ] // bounds check hint to compiler; see golang.org/issue/14808
298 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
299 z[ 0 ] = bigEndianUint48(in[ 0 : 6 ])
300 return z
301 }
302
303 // SetBytes7 sets z from a 7-byte big-endian slice and returns z.
304 // Panics if input is shorter than 7 bytes.
305 //
306 // Parameters:
307 // - in: the byte sequence whose first 7 bytes are decoded in big-endian order; it must contain at least 7 bytes
308 //
309 // Returns:
310 // - result: z after decoding the first 7 bytes of in in big-endian order
311 func (z *Uint) SetBytes7(in [] byte ) *Uint {
312 _ = in[ 6 ] // bounds check hint to compiler; see golang.org/issue/14808
313 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
314 z[ 0 ] = bigEndianUint56(in[ 0 : 7 ])
315 return z
316 }
317
318 // SetBytes8 sets z from an 8-byte big-endian slice and returns z.
319 // Panics if input is shorter than 8 bytes.
320 //
321 // Parameters:
322 // - in: the byte sequence whose first 8 bytes are decoded in big-endian order; it must contain at least 8 bytes
323 //
324 // Returns:
325 // - result: z after decoding the first 8 bytes of in in big-endian order
326 func (z *Uint) SetBytes8(in [] byte ) *Uint {
327 _ = in[ 7 ] // bounds check hint to compiler; see golang.org/issue/14808
328 z[ 3 ], z[ 2 ], z[ 1 ] = 0 , 0 , 0
329 z[ 0 ] = binary.BigEndian.Uint64(in[ 0 : 8 ])
330 return z
331 }
332
333 // SetBytes9 sets z from a 9-byte big-endian slice and returns z.
334 // Panics if input is shorter than 9 bytes.
335 //
336 // Parameters:
337 // - in: the byte sequence whose first 9 bytes are decoded in big-endian order; it must contain at least 9 bytes
338 //
339 // Returns:
340 // - result: z after decoding the first 9 bytes of in in big-endian order
341 func (z *Uint) SetBytes9(in [] byte ) *Uint {
342 _ = in[ 8 ] // bounds check hint to compiler; see golang.org/issue/14808
343 z[ 3 ], z[ 2 ] = 0 , 0
344 z[ 1 ] = uint64 (in[ 0 ])
345 z[ 0 ] = binary.BigEndian.Uint64(in[ 1 : 9 ])
346 return z
347 }
348
349 // SetBytes10 sets z from a 10-byte big-endian slice and returns z.
350 // Panics if input is shorter than 10 bytes.
351 //
352 // Parameters:
353 // - in: the byte sequence whose first 10 bytes are decoded in big-endian order; it must contain at least 10 bytes
354 //
355 // Returns:
356 // - result: z after decoding the first 10 bytes of in in big-endian order
357 func (z *Uint) SetBytes10(in [] byte ) *Uint {
358 _ = in[ 9 ] // bounds check hint to compiler; see golang.org/issue/14808
359 z[ 3 ], z[ 2 ] = 0 , 0
360 z[ 1 ] = uint64 (binary.BigEndian.Uint16(in[ 0 : 2 ]))
361 z[ 0 ] = binary.BigEndian.Uint64(in[ 2 : 10 ])
362 return z
363 }
364
365 // SetBytes11 sets z from an 11-byte big-endian slice and returns z.
366 // Panics if input is shorter than 11 bytes.
367 //
368 // Parameters:
369 // - in: the byte sequence whose first 11 bytes are decoded in big-endian order; it must contain at least 11 bytes
370 //
371 // Returns:
372 // - result: z after decoding the first 11 bytes of in in big-endian order
373 func (z *Uint) SetBytes11(in [] byte ) *Uint {
374 _ = in[ 10 ] // bounds check hint to compiler; see golang.org/issue/14808
375 z[ 3 ], z[ 2 ] = 0 , 0
376 z[ 1 ] = uint64 (binary.BigEndian.Uint16(in[ 1 : 3 ])) | uint64 (in[ 0 ])<< 16
377 z[ 0 ] = binary.BigEndian.Uint64(in[ 3 : 11 ])
378 return z
379 }
380
381 // SetBytes12 sets z from a 12-byte big-endian slice and returns z.
382 // Panics if input is shorter than 12 bytes.
383 //
384 // Parameters:
385 // - in: the byte sequence whose first 12 bytes are decoded in big-endian order; it must contain at least 12 bytes
386 //
387 // Returns:
388 // - result: z after decoding the first 12 bytes of in in big-endian order
389 func (z *Uint) SetBytes12(in [] byte ) *Uint {
390 _ = in[ 11 ] // bounds check hint to compiler; see golang.org/issue/14808
391 z[ 3 ], z[ 2 ] = 0 , 0
392 z[ 1 ] = uint64 (binary.BigEndian.Uint32(in[ 0 : 4 ]))
393 z[ 0 ] = binary.BigEndian.Uint64(in[ 4 : 12 ])
394 return z
395 }
396
397 // SetBytes13 sets z from a 13-byte big-endian slice and returns z.
398 // Panics if input is shorter than 13 bytes.
399 //
400 // Parameters:
401 // - in: the byte sequence whose first 13 bytes are decoded in big-endian order; it must contain at least 13 bytes
402 //
403 // Returns:
404 // - result: z after decoding the first 13 bytes of in in big-endian order
405 func (z *Uint) SetBytes13(in [] byte ) *Uint {
406 _ = in[ 12 ] // bounds check hint to compiler; see golang.org/issue/14808
407 z[ 3 ], z[ 2 ] = 0 , 0
408 z[ 1 ] = bigEndianUint40(in[ 0 : 5 ])
409 z[ 0 ] = binary.BigEndian.Uint64(in[ 5 : 13 ])
410 return z
411 }
412
413 // SetBytes14 sets z from a 14-byte big-endian slice and returns z.
414 // Panics if input is shorter than 14 bytes.
415 //
416 // Parameters:
417 // - in: the byte sequence whose first 14 bytes are decoded in big-endian order; it must contain at least 14 bytes
418 //
419 // Returns:
420 // - result: z after decoding the first 14 bytes of in in big-endian order
421 func (z *Uint) SetBytes14(in [] byte ) *Uint {
422 _ = in[ 13 ] // bounds check hint to compiler; see golang.org/issue/14808
423 z[ 3 ], z[ 2 ] = 0 , 0
424 z[ 1 ] = bigEndianUint48(in[ 0 : 6 ])
425 z[ 0 ] = binary.BigEndian.Uint64(in[ 6 : 14 ])
426 return z
427 }
428
429 // SetBytes15 sets z from a 15-byte big-endian slice and returns z.
430 // Panics if input is shorter than 15 bytes.
431 //
432 // Parameters:
433 // - in: the byte sequence whose first 15 bytes are decoded in big-endian order; it must contain at least 15 bytes
434 //
435 // Returns:
436 // - result: z after decoding the first 15 bytes of in in big-endian order
437 func (z *Uint) SetBytes15(in [] byte ) *Uint {
438 _ = in[ 14 ] // bounds check hint to compiler; see golang.org/issue/14808
439 z[ 3 ], z[ 2 ] = 0 , 0
440 z[ 1 ] = bigEndianUint56(in[ 0 : 7 ])
441 z[ 0 ] = binary.BigEndian.Uint64(in[ 7 : 15 ])
442 return z
443 }
444
445 // SetBytes16 sets z from a 16-byte big-endian slice and returns z.
446 // Panics if input is shorter than 16 bytes.
447 //
448 // Parameters:
449 // - in: the byte sequence whose first 16 bytes are decoded in big-endian order; it must contain at least 16 bytes
450 //
451 // Returns:
452 // - result: z after decoding the first 16 bytes of in in big-endian order
453 func (z *Uint) SetBytes16(in [] byte ) *Uint {
454 _ = in[ 15 ] // bounds check hint to compiler; see golang.org/issue/14808
455 z[ 3 ], z[ 2 ] = 0 , 0
456 z[ 1 ] = binary.BigEndian.Uint64(in[ 0 : 8 ])
457 z[ 0 ] = binary.BigEndian.Uint64(in[ 8 : 16 ])
458 return z
459 }
460
461 // SetBytes17 sets z from a 17-byte big-endian slice and returns z.
462 // Panics if input is shorter than 17 bytes.
463 //
464 // Parameters:
465 // - in: the byte sequence whose first 17 bytes are decoded in big-endian order; it must contain at least 17 bytes
466 //
467 // Returns:
468 // - result: z after decoding the first 17 bytes of in in big-endian order
469 func (z *Uint) SetBytes17(in [] byte ) *Uint {
470 _ = in[ 16 ] // bounds check hint to compiler; see golang.org/issue/14808
471 z[ 3 ] = 0
472 z[ 2 ] = uint64 (in[ 0 ])
473 z[ 1 ] = binary.BigEndian.Uint64(in[ 1 : 9 ])
474 z[ 0 ] = binary.BigEndian.Uint64(in[ 9 : 17 ])
475 return z
476 }
477
478 // SetBytes18 sets z from an 18-byte big-endian slice and returns z.
479 // Panics if input is shorter than 18 bytes.
480 //
481 // Parameters:
482 // - in: the byte sequence whose first 18 bytes are decoded in big-endian order; it must contain at least 18 bytes
483 //
484 // Returns:
485 // - result: z after decoding the first 18 bytes of in in big-endian order
486 func (z *Uint) SetBytes18(in [] byte ) *Uint {
487 _ = in[ 17 ] // bounds check hint to compiler; see golang.org/issue/14808
488 z[ 3 ] = 0
489 z[ 2 ] = uint64 (binary.BigEndian.Uint16(in[ 0 : 2 ]))
490 z[ 1 ] = binary.BigEndian.Uint64(in[ 2 : 10 ])
491 z[ 0 ] = binary.BigEndian.Uint64(in[ 10 : 18 ])
492 return z
493 }
494
495 // SetBytes19 sets z from a 19-byte big-endian slice and returns z.
496 // Panics if input is shorter than 19 bytes.
497 //
498 // Parameters:
499 // - in: the byte sequence whose first 19 bytes are decoded in big-endian order; it must contain at least 19 bytes
500 //
501 // Returns:
502 // - result: z after decoding the first 19 bytes of in in big-endian order
503 func (z *Uint) SetBytes19(in [] byte ) *Uint {
504 _ = in[ 18 ] // bounds check hint to compiler; see golang.org/issue/14808
505 z[ 3 ] = 0
506 z[ 2 ] = uint64 (binary.BigEndian.Uint16(in[ 1 : 3 ])) | uint64 (in[ 0 ])<< 16
507 z[ 1 ] = binary.BigEndian.Uint64(in[ 3 : 11 ])
508 z[ 0 ] = binary.BigEndian.Uint64(in[ 11 : 19 ])
509 return z
510 }
511
512 // SetBytes20 sets z from a 20-byte big-endian slice and returns z.
513 // Panics if input is shorter than 20 bytes.
514 //
515 // Parameters:
516 // - in: the byte sequence whose first 20 bytes are decoded in big-endian order; it must contain at least 20 bytes
517 //
518 // Returns:
519 // - result: z after decoding the first 20 bytes of in in big-endian order
520 func (z *Uint) SetBytes20(in [] byte ) *Uint {
521 _ = in[ 19 ] // bounds check hint to compiler; see golang.org/issue/14808
522 z[ 3 ] = 0
523 z[ 2 ] = uint64 (binary.BigEndian.Uint32(in[ 0 : 4 ]))
524 z[ 1 ] = binary.BigEndian.Uint64(in[ 4 : 12 ])
525 z[ 0 ] = binary.BigEndian.Uint64(in[ 12 : 20 ])
526 return z
527 }
528
529 // SetBytes21 sets z from a 21-byte big-endian slice and returns z.
530 // Panics if input is shorter than 21 bytes.
531 //
532 // Parameters:
533 // - in: the byte sequence whose first 21 bytes are decoded in big-endian order; it must contain at least 21 bytes
534 //
535 // Returns:
536 // - result: z after decoding the first 21 bytes of in in big-endian order
537 func (z *Uint) SetBytes21(in [] byte ) *Uint {
538 _ = in[ 20 ] // bounds check hint to compiler; see golang.org/issue/14808
539 z[ 3 ] = 0
540 z[ 2 ] = bigEndianUint40(in[ 0 : 5 ])
541 z[ 1 ] = binary.BigEndian.Uint64(in[ 5 : 13 ])
542 z[ 0 ] = binary.BigEndian.Uint64(in[ 13 : 21 ])
543 return z
544 }
545
546 // SetBytes22 sets z from a 22-byte big-endian slice and returns z.
547 // Panics if input is shorter than 22 bytes.
548 //
549 // Parameters:
550 // - in: the byte sequence whose first 22 bytes are decoded in big-endian order; it must contain at least 22 bytes
551 //
552 // Returns:
553 // - result: z after decoding the first 22 bytes of in in big-endian order
554 func (z *Uint) SetBytes22(in [] byte ) *Uint {
555 _ = in[ 21 ] // bounds check hint to compiler; see golang.org/issue/14808
556 z[ 3 ] = 0
557 z[ 2 ] = bigEndianUint48(in[ 0 : 6 ])
558 z[ 1 ] = binary.BigEndian.Uint64(in[ 6 : 14 ])
559 z[ 0 ] = binary.BigEndian.Uint64(in[ 14 : 22 ])
560 return z
561 }
562
563 // SetBytes23 sets z from a 23-byte big-endian slice and returns z.
564 // Panics if input is shorter than 23 bytes.
565 //
566 // Parameters:
567 // - in: the byte sequence whose first 23 bytes are decoded in big-endian order; it must contain at least 23 bytes
568 //
569 // Returns:
570 // - result: z after decoding the first 23 bytes of in in big-endian order
571 func (z *Uint) SetBytes23(in [] byte ) *Uint {
572 _ = in[ 22 ] // bounds check hint to compiler; see golang.org/issue/14808
573 z[ 3 ] = 0
574 z[ 2 ] = bigEndianUint56(in[ 0 : 7 ])
575 z[ 1 ] = binary.BigEndian.Uint64(in[ 7 : 15 ])
576 z[ 0 ] = binary.BigEndian.Uint64(in[ 15 : 23 ])
577 return z
578 }
579
580 // SetBytes24 sets z from a 24-byte big-endian slice and returns z.
581 // Panics if input is shorter than 24 bytes.
582 //
583 // Parameters:
584 // - in: the byte sequence whose first 24 bytes are decoded in big-endian order; it must contain at least 24 bytes
585 //
586 // Returns:
587 // - result: z after decoding the first 24 bytes of in in big-endian order
588 func (z *Uint) SetBytes24(in [] byte ) *Uint {
589 _ = in[ 23 ] // bounds check hint to compiler; see golang.org/issue/14808
590 z[ 3 ] = 0
591 z[ 2 ] = binary.BigEndian.Uint64(in[ 0 : 8 ])
592 z[ 1 ] = binary.BigEndian.Uint64(in[ 8 : 16 ])
593 z[ 0 ] = binary.BigEndian.Uint64(in[ 16 : 24 ])
594 return z
595 }
596
597 // SetBytes25 sets z from a 25-byte big-endian slice and returns z.
598 // Panics if input is shorter than 25 bytes.
599 //
600 // Parameters:
601 // - in: the byte sequence whose first 25 bytes are decoded in big-endian order; it must contain at least 25 bytes
602 //
603 // Returns:
604 // - result: z after decoding the first 25 bytes of in in big-endian order
605 func (z *Uint) SetBytes25(in [] byte ) *Uint {
606 _ = in[ 24 ] // bounds check hint to compiler; see golang.org/issue/14808
607 z[ 3 ] = uint64 (in[ 0 ])
608 z[ 2 ] = binary.BigEndian.Uint64(in[ 1 : 9 ])
609 z[ 1 ] = binary.BigEndian.Uint64(in[ 9 : 17 ])
610 z[ 0 ] = binary.BigEndian.Uint64(in[ 17 : 25 ])
611 return z
612 }
613
614 // SetBytes26 sets z from a 26-byte big-endian slice and returns z.
615 // Panics if input is shorter than 26 bytes.
616 //
617 // Parameters:
618 // - in: the byte sequence whose first 26 bytes are decoded in big-endian order; it must contain at least 26 bytes
619 //
620 // Returns:
621 // - result: z after decoding the first 26 bytes of in in big-endian order
622 func (z *Uint) SetBytes26(in [] byte ) *Uint {
623 _ = in[ 25 ] // bounds check hint to compiler; see golang.org/issue/14808
624 z[ 3 ] = uint64 (binary.BigEndian.Uint16(in[ 0 : 2 ]))
625 z[ 2 ] = binary.BigEndian.Uint64(in[ 2 : 10 ])
626 z[ 1 ] = binary.BigEndian.Uint64(in[ 10 : 18 ])
627 z[ 0 ] = binary.BigEndian.Uint64(in[ 18 : 26 ])
628 return z
629 }
630
631 // SetBytes27 sets z from a 27-byte big-endian slice and returns z.
632 // Panics if input is shorter than 27 bytes.
633 //
634 // Parameters:
635 // - in: the byte sequence whose first 27 bytes are decoded in big-endian order; it must contain at least 27 bytes
636 //
637 // Returns:
638 // - result: z after decoding the first 27 bytes of in in big-endian order
639 func (z *Uint) SetBytes27(in [] byte ) *Uint {
640 _ = in[ 26 ] // bounds check hint to compiler; see golang.org/issue/14808
641 z[ 3 ] = uint64 (binary.BigEndian.Uint16(in[ 1 : 3 ])) | uint64 (in[ 0 ])<< 16
642 z[ 2 ] = binary.BigEndian.Uint64(in[ 3 : 11 ])
643 z[ 1 ] = binary.BigEndian.Uint64(in[ 11 : 19 ])
644 z[ 0 ] = binary.BigEndian.Uint64(in[ 19 : 27 ])
645 return z
646 }
647
648 // SetBytes28 sets z from a 28-byte big-endian slice and returns z.
649 // Panics if input is shorter than 28 bytes.
650 //
651 // Parameters:
652 // - in: the byte sequence whose first 28 bytes are decoded in big-endian order; it must contain at least 28 bytes
653 //
654 // Returns:
655 // - result: z after decoding the first 28 bytes of in in big-endian order
656 func (z *Uint) SetBytes28(in [] byte ) *Uint {
657 _ = in[ 27 ] // bounds check hint to compiler; see golang.org/issue/14808
658 z[ 3 ] = uint64 (binary.BigEndian.Uint32(in[ 0 : 4 ]))
659 z[ 2 ] = binary.BigEndian.Uint64(in[ 4 : 12 ])
660 z[ 1 ] = binary.BigEndian.Uint64(in[ 12 : 20 ])
661 z[ 0 ] = binary.BigEndian.Uint64(in[ 20 : 28 ])
662 return z
663 }
664
665 // SetBytes29 sets z from a 29-byte big-endian slice and returns z.
666 // Panics if input is shorter than 29 bytes.
667 //
668 // Parameters:
669 // - in: the byte sequence whose first 29 bytes are decoded in big-endian order; it must contain at least 29 bytes
670 //
671 // Returns:
672 // - result: z after decoding the first 29 bytes of in in big-endian order
673 func (z *Uint) SetBytes29(in [] byte ) *Uint {
674 _ = in[ 28 ] // bounds check hint to compiler; see golang.org/issue/14808
675 z[ 3 ] = bigEndianUint40(in[ 0 : 5 ])
676 z[ 2 ] = binary.BigEndian.Uint64(in[ 5 : 13 ])
677 z[ 1 ] = binary.BigEndian.Uint64(in[ 13 : 21 ])
678 z[ 0 ] = binary.BigEndian.Uint64(in[ 21 : 29 ])
679 return z
680 }
681
682 // SetBytes30 sets z from a 30-byte big-endian slice and returns z.
683 // Panics if input is shorter than 30 bytes.
684 //
685 // Parameters:
686 // - in: the byte sequence whose first 30 bytes are decoded in big-endian order; it must contain at least 30 bytes
687 //
688 // Returns:
689 // - result: z after decoding the first 30 bytes of in in big-endian order
690 func (z *Uint) SetBytes30(in [] byte ) *Uint {
691 _ = in[ 29 ] // bounds check hint to compiler; see golang.org/issue/14808
692 z[ 3 ] = bigEndianUint48(in[ 0 : 6 ])
693 z[ 2 ] = binary.BigEndian.Uint64(in[ 6 : 14 ])
694 z[ 1 ] = binary.BigEndian.Uint64(in[ 14 : 22 ])
695 z[ 0 ] = binary.BigEndian.Uint64(in[ 22 : 30 ])
696 return z
697 }
698
699 // SetBytes31 sets z from a 31-byte big-endian slice and returns z.
700 // Panics if input is shorter than 31 bytes.
701 //
702 // Parameters:
703 // - in: the byte sequence whose first 31 bytes are decoded in big-endian order; it must contain at least 31 bytes
704 //
705 // Returns:
706 // - result: z after decoding the first 31 bytes of in in big-endian order
707 func (z *Uint) SetBytes31(in [] byte ) *Uint {
708 _ = in[ 30 ] // bounds check hint to compiler; see golang.org/issue/14808
709 z[ 3 ] = bigEndianUint56(in[ 0 : 7 ])
710 z[ 2 ] = binary.BigEndian.Uint64(in[ 7 : 15 ])
711 z[ 1 ] = binary.BigEndian.Uint64(in[ 15 : 23 ])
712 z[ 0 ] = binary.BigEndian.Uint64(in[ 23 : 31 ])
713 return z
714 }
715
716 // SetBytes32 sets z from a 32-byte big-endian slice and returns z.
717 // Panics if input is shorter than 32 bytes.
718 //
719 // Parameters:
720 // - in: the byte sequence whose first 32 bytes are decoded in big-endian order; it must contain at least 32 bytes
721 //
722 // Returns:
723 // - result: z after decoding the first 32 bytes of in in big-endian order
724 func (z *Uint) SetBytes32(in [] byte ) *Uint {
725 _ = in[ 31 ] // bounds check hint to compiler; see golang.org/issue/14808
726 z[ 3 ] = binary.BigEndian.Uint64(in[ 0 : 8 ])
727 z[ 2 ] = binary.BigEndian.Uint64(in[ 8 : 16 ])
728 z[ 1 ] = binary.BigEndian.Uint64(in[ 16 : 24 ])
729 z[ 0 ] = binary.BigEndian.Uint64(in[ 24 : 32 ])
730 return z
731 }
732
733 // Utility methods that are "missing" among the bigEndian.UintXX methods.
734
735 // bigEndianUint40 returns the uint64 value represented by the 5 bytes in big-endian order.
736 func bigEndianUint40(b [] byte ) uint64 {
737 _ = b[ 4 ] // bounds check hint to compiler; see golang.org/issue/14808
738 return uint64 (b[ 4 ]) | uint64 (b[ 3 ])<< 8 | uint64 (b[ 2 ])<< 16 | uint64 (b[ 1 ])<< 24 |
739 uint64 (b[ 0 ])<< 32
740 }
741
742 // bigEndianUint56 returns the uint64 value represented by the 7 bytes in big-endian order.
743 func bigEndianUint56(b [] byte ) uint64 {
744 _ = b[ 6 ] // bounds check hint to compiler; see golang.org/issue/14808
745 return uint64 (b[ 6 ]) | uint64 (b[ 5 ])<< 8 | uint64 (b[ 4 ])<< 16 | uint64 (b[ 3 ])<< 24 |
746 uint64 (b[ 2 ])<< 32 | uint64 (b[ 1 ])<< 40 | uint64 (b[ 0 ])<< 48
747 }
748
749 // bigEndianUint48 returns the uint64 value represented by the 6 bytes in big-endian order.
750 func bigEndianUint48(b [] byte ) uint64 {
751 _ = b[ 5 ] // bounds check hint to compiler; see golang.org/issue/14808
752 return uint64 (b[ 5 ]) | uint64 (b[ 4 ])<< 8 | uint64 (b[ 3 ])<< 16 | uint64 (b[ 2 ])<< 24 |
753 uint64 (b[ 1 ])<< 32 | uint64 (b[ 0 ])<< 40
754 }
755