1///|
2/// `@crc32.Digest` implements the 32-bit cyclic redundancy check, or CRC-32,
3/// checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
4/// information.
5/// This package is based on the Go Rosetta Stone implementation found here:
6/// https://rosettacode.org/wiki/CRC-32
7pub(all) struct Digest {
8 mut UInt
crc : UInt
UInt
9 String
name : String
String
10}
11
12///|
13/// `Digest::new` returns a new, reset Digest, ready to sum.
14pub fn struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest::() -> Digest
Digest::new returns a new, reset Digest, ready to sum.
new() -> struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest {
15 { UInt
crc: 0U.(self : UInt) -> UInt
Performs a bitwise NOT operation on an unsigned 32-bit integer. Flips all
bits in the number (changes each 0 to 1 and each 1 to 0).
Parameters:
self : The unsigned 32-bit integer value on which to perform the bitwise
NOT operation.
Returns a new unsigned 32-bit integer where each bit is inverted from the
input value.
Example:
test "UInt::lnot" {
let x = 0xFF00U // Binary: 1111_1111_0000_0000
inspect(x.lnot(), content="4294902015") // Binary: ...0000_0000_1111_1111
}
lnot(), String
name: "crc32" }
16}
17
18///|
19let &HashFunc
_trait : &trait HashFunc {
name(Self) -> String
write(Self, Byte) -> Unit
check_sum(Self) -> String
}
HashFunc represents a hash algorithm like @crc32, @md5, or @sha256.
HashFunc = struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest::() -> Digest
Digest::new returns a new, reset Digest, ready to sum.
new()
20
21///|
22pub impl trait HashFunc {
name(Self) -> String
write(Self, Byte) -> Unit
check_sum(Self) -> String
}
HashFunc represents a hash algorithm like @crc32, @md5, or @sha256.
HashFunc for struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest with (self : Digest) -> String
name(Digest
self) {
23 Digest
self.String
name
24}
25
26///|
27/// `digest` returns the final crc32 as a UInt.
28pub fn (self : Digest) -> UInt
digest returns the final crc32 as a UInt.
digest(Digest
self : struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest) -> UInt
UInt {
29 Digest
self.UInt
crc.(self : UInt) -> UInt
Performs a bitwise NOT operation on an unsigned 32-bit integer. Flips all
bits in the number (changes each 0 to 1 and each 1 to 0).
Parameters:
self : The unsigned 32-bit integer value on which to perform the bitwise
NOT operation.
Returns a new unsigned 32-bit integer where each bit is inverted from the
input value.
Example:
test "UInt::lnot" {
let x = 0xFF00U // Binary: 1111_1111_0000_0000
inspect(x.lnot(), content="4294902015") // Binary: ...0000_0000_1111_1111
}
lnot()
30}
31
32///|
33/// `check_sum` returns the final crc32 as a hex string.
34pub impl trait HashFunc {
name(Self) -> String
write(Self, Byte) -> Unit
check_sum(Self) -> String
}
HashFunc represents a hash algorithm like @crc32, @md5, or @sha256.
HashFunc for struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest with (self : Digest) -> String
check_sum returns the final crc32 as a hex string.
check_sum(Digest
self) {
35 let UInt
digest = Digest
self.UInt
crc.(self : UInt) -> UInt
Performs a bitwise NOT operation on an unsigned 32-bit integer. Flips all
bits in the number (changes each 0 to 1 and each 1 to 0).
Parameters:
self : The unsigned 32-bit integer value on which to perform the bitwise
NOT operation.
Returns a new unsigned 32-bit integer where each bit is inverted from the
input value.
Example:
test "UInt::lnot" {
let x = 0xFF00U // Binary: 1111_1111_0000_0000
inspect(x.lnot(), content="4294902015") // Binary: ...0000_0000_1111_1111
}
lnot()
36 let @buffer.T
result = (size_hint~ : Int) -> @buffer.T
Creates a new extensible buffer with specified initial capacity. If the
initial capacity is less than 1, the buffer will be initialized with capacity
1.
Parameters:
size_hint : Initial capacity of the buffer in bytes. Defaults to 0.
Returns a new buffer of type T.
Example:
test "new" {
let buf = @buffer.new(size_hint=10)
inspect(buf.length(), content="0")
buf.write_string("test")
inspect(buf.length(), content="8")
}
@buffer.new(Int
size_hint=8)
37 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 28) (UInt, UInt) -> UInt
& 0xf))
38 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 24) (UInt, UInt) -> UInt
& 0xf))
39 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 20) (UInt, UInt) -> UInt
& 0xf))
40 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 16) (UInt, UInt) -> UInt
& 0xf))
41 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 12) (UInt, UInt) -> UInt
& 0xf))
42 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 8) (UInt, UInt) -> UInt
& 0xf))
43 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex((UInt
digest (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 4) (UInt, UInt) -> UInt
& 0xf))
44 @buffer.T
result.(self : @buffer.T, value : Char) -> Unit
Writes a UTF-16LE encoded character into the buffer. Automatically grows the
buffer if necessary.
Parameters:
buffer : The buffer to write to.char : The character to be written.
Example:
test "write_char" {
let buf = @buffer.new()
buf.write_char('A')
inspect(buf.contents(), content=
#|b"\x41\x00"
)
}
write_char((v : UInt) -> Char
to_hex(UInt
digest (UInt, UInt) -> UInt
& 0xf))
45 @buffer.T
result.(self : @buffer.T) -> Bytes
Returns a copy of the buffer's content as a sequence of bytes.
Parameters:
buffer : The buffer to read from.
Returns a Bytes object containing all bytes written to the buffer.
Example:
test "contents" {
let buf = @buffer.new()
buf.write_string("Test")
inspect(
buf.contents(),
content=
#|b"\x54\x00\x65\x00\x73\x00\x74\x00"
,
)
}
contents().(self : Bytes, offset~ : Int = .., length? : Int) -> String
Return an unchecked string, containing the subsequence of self that starts at
offset and has length length. Both offset and length
are indexed by byte.
Note this function does not validate the encoding of the byte sequence,
it simply copy the bytes into a new String.
to_unchecked_string()
46}
47
48///|
49fn (v : UInt) -> Char
to_hex(UInt
v : UInt
UInt) -> Char
Char {
50 let Int
v = UInt
v.(self : UInt) -> Int
reinterpret the unsigned int as signed int
For number within the range of 0..=2^31-1,
the value is the same. For number within the range of 2^31..=2^32-1,
the value is negative
reinterpret_as_int()
51 if Int
v (self_ : Int, other : Int) -> Bool
< 10 {
52 (Int) -> Char
Int::(self : Int) -> Char
unsafe_to_char(Int
v (self : Int, other : Int) -> Int
Adds two 32-bit signed integers. Performs two's complement arithmetic, which
means the operation will wrap around if the result exceeds the range of a
32-bit integer.
Parameters:
self : The first integer operand.other : The second integer operand.
Returns a new integer that is the sum of the two operands. If the
mathematical sum exceeds the range of a 32-bit integer (-2,147,483,648 to
2,147,483,647), the result wraps around according to two's complement rules.
Example:
test "Int::op_add" {
inspect(42 + 1, content="43")
inspect(2147483647 + 1, content="-2147483648") // Overflow wraps around to minimum value
}
+ b'0'.(self : Byte) -> Int
Converts a byte value to a 32-bit signed integer. The resulting integer will
have the same binary representation as the byte value, preserving the
numerical value in the range [0, 255].
Parameters:
byte : The byte value to be converted to an integer.
Returns a 32-bit signed integer representing the same numerical value as the
input byte.
Example:
test "Byte::to_int" {
let b = b'\xFF' // byte with value 255
inspect(b.to_int(), content="255")
let zero = b'\x00'
inspect(zero.to_int(), content="0")
}
to_int())
53 } else {
54 (Int) -> Char
Int::(self : Int) -> Char
unsafe_to_char(Int
v (self : Int, other : Int) -> Int
Performs subtraction between two 32-bit integers, following standard two's
complement arithmetic rules. When the result overflows or underflows, it
wraps around within the 32-bit integer range.
Parameters:
self : The minuend (the number being subtracted from).other : The subtrahend (the number to subtract).
Returns the difference between self and other.
Example:
test "Int::op_sub" {
let a = 42
let b = 10
inspect(a - b, content="32")
let max = 2147483647 // Int maximum value
inspect(max - -1, content="-2147483648") // Overflow case
}
- 10 (self : Int, other : Int) -> Int
Adds two 32-bit signed integers. Performs two's complement arithmetic, which
means the operation will wrap around if the result exceeds the range of a
32-bit integer.
Parameters:
self : The first integer operand.other : The second integer operand.
Returns a new integer that is the sum of the two operands. If the
mathematical sum exceeds the range of a 32-bit integer (-2,147,483,648 to
2,147,483,647), the result wraps around according to two's complement rules.
Example:
test "Int::op_add" {
inspect(42 + 1, content="43")
inspect(2147483647 + 1, content="-2147483648") // Overflow wraps around to minimum value
}
+ b'a'.(self : Byte) -> Int
Converts a byte value to a 32-bit signed integer. The resulting integer will
have the same binary representation as the byte value, preserving the
numerical value in the range [0, 255].
Parameters:
byte : The byte value to be converted to an integer.
Returns a 32-bit signed integer representing the same numerical value as the
input byte.
Example:
test "Byte::to_int" {
let b = b'\xFF' // byte with value 255
inspect(b.to_int(), content="255")
let zero = b'\x00'
inspect(zero.to_int(), content="0")
}
to_int())
55 }
56}
57
58///|
59/// `write` writes a byte to the digest.
60pub impl trait HashFunc {
name(Self) -> String
write(Self, Byte) -> Unit
check_sum(Self) -> String
}
HashFunc represents a hash algorithm like @crc32, @md5, or @sha256.
HashFunc for struct Digest {
mut crc: UInt
name: String
}
@crc32.Digest implements the 32-bit cyclic redundancy check, or CRC-32,
checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
information.
This package is based on the Go Rosetta Stone implementation found here:
https://rosettacode.org/wiki/CRC-32
Digest with (self : Digest, b : Byte) -> Unit
write writes a byte to the digest.
write(Digest
self, Byte
b) {
61 Digest
self.UInt
crc = FixedArray[UInt]
table[(Digest
self.UInt
crc.(self : UInt) -> Byte
Converts an unsigned 32-bit integer to a byte by taking its least significant
8 bits. Any bits beyond the first 8 bits are truncated.
Parameters:
self : The unsigned 32-bit integer to be converted. Only the least
significant 8 bits will be used.
Returns a byte containing the least significant 8 bits of the input integer.
Example:
test "UInt::to_byte" {
let n = 258U // In binary: 100000010
inspect(n.to_byte(), content="b'\\x02'") // Only keeps 00000010
let big = 4294967295U // Maximum value of UInt
inspect(big.to_byte(), content="b'\\xFF'") // Only keeps 11111111
}
to_byte() (self : Byte, that : Byte) -> Byte
Performs a bitwise AND operation between two Byte values.
Parameters:
byte1 : The first Byte value to perform the bitwise AND operation with.byte2 : The second Byte value to perform the bitwise AND operation
with.
Returns the result of the bitwise AND operation as a Byte.
& b'\xff').(self : Byte, that : Byte) -> Byte
Performs a bitwise XOR operation between two Byte values.
Parameters:
self : The first Byte value.that : The second Byte value.
Returns the result of the bitwise XOR operation as a Byte.
lxor(Byte
b).(self : Byte) -> Int
Converts a byte value to a 32-bit signed integer. The resulting integer will
have the same binary representation as the byte value, preserving the
numerical value in the range [0, 255].
Parameters:
byte : The byte value to be converted to an integer.
Returns a 32-bit signed integer representing the same numerical value as the
input byte.
Example:
test "Byte::to_int" {
let b = b'\xFF' // byte with value 255
inspect(b.to_int(), content="255")
let zero = b'\x00'
inspect(zero.to_int(), content="0")
}
to_int()] (UInt, UInt) -> UInt
^
62 (Digest
self.UInt
crc (self : UInt, shift : Int) -> UInt
Performs a logical right shift operation on an unsigned 32-bit integer. The
operation shifts all bits to the right by a specified number of positions,
filling the leftmost positions with zeros.
Parameters:
self : The unsigned 32-bit integer to be shifted.shift : The number of positions to shift right. If this value is
negative, the behavior is undefined. Values larger than 31 are masked with & 31.
Returns a new unsigned 32-bit integer containing the result of the right
shift operation.
Example:
test "UInt::op_shr" {
let x = 0xFF000000U
inspect(x >> 8, content="16711680") // 0x00FF0000
inspect(x >> 24, content="255") // 0x000000FF
}
test "UInt::op_shr/large_shift" {
let x = 0xFF000000U
inspect(x >> 32, content="4278190080") // Same as x >> 0 due to masking
}
>> 8)
63}
64
65///|
66let FixedArray[UInt]
table : type FixedArray[A]
FixedArray[UInt
UInt] = [
67 0, 1996959894, 3993919788, 2567524794, 124634137, 1886057615, 3915621685, 2657392035,
68 249268274, 2044508324, 3772115230, 2547177864, 162941995, 2125561021, 3887607047,
69 2428444049, 498536548, 1789927666, 4089016648, 2227061214, 450548861, 1843258603,
70 4107580753, 2211677639, 325883990, 1684777152, 4251122042, 2321926636, 335633487,
71 1661365465, 4195302755, 2366115317, 997073096, 1281953886, 3579855332, 2724688242,
72 1006888145, 1258607687, 3524101629, 2768942443, 901097722, 1119000684, 3686517206,
73 2898065728, 853044451, 1172266101, 3705015759, 2882616665, 651767980, 1373503546,
74 3369554304, 3218104598, 565507253, 1454621731, 3485111705, 3099436303, 671266974,
75 1594198024, 3322730930, 2970347812, 795835527, 1483230225, 3244367275, 3060149565,
76 1994146192, 31158534, 2563907772, 4023717930, 1907459465, 112637215, 2680153253,
77 3904427059, 2013776290, 251722036, 2517215374, 3775830040, 2137656763, 141376813,
78 2439277719, 3865271297, 1802195444, 476864866, 2238001368, 4066508878, 1812370925,
79 453092731, 2181625025, 4111451223, 1706088902, 314042704, 2344532202, 4240017532,
80 1658658271, 366619977, 2362670323, 4224994405, 1303535960, 984961486, 2747007092,
81 3569037538, 1256170817, 1037604311, 2765210733, 3554079995, 1131014506, 879679996,
82 2909243462, 3663771856, 1141124467, 855842277, 2852801631, 3708648649, 1342533948,
83 654459306, 3188396048, 3373015174, 1466479909, 544179635, 3110523913, 3462522015,
84 1591671054, 702138776, 2966460450, 3352799412, 1504918807, 783551873, 3082640443,
85 3233442989, 3988292384, 2596254646, 62317068, 1957810842, 3939845945, 2647816111,
86 81470997, 1943803523, 3814918930, 2489596804, 225274430, 2053790376, 3826175755,
87 2466906013, 167816743, 2097651377, 4027552580, 2265490386, 503444072, 1762050814,
88 4150417245, 2154129355, 426522225, 1852507879, 4275313526, 2312317920, 282753626,
89 1742555852, 4189708143, 2394877945, 397917763, 1622183637, 3604390888, 2714866558,
90 953729732, 1340076626, 3518719985, 2797360999, 1068828381, 1219638859, 3624741850,
91 2936675148, 906185462, 1090812512, 3747672003, 2825379669, 829329135, 1181335161,
92 3412177804, 3160834842, 628085408, 1382605366, 3423369109, 3138078467, 570562233,
93 1426400815, 3317316542, 2998733608, 733239954, 1555261956, 3268935591, 3050360625,
94 752459403, 1541320221, 2607071920, 3965973030, 1969922972, 40735498, 2617837225,
95 3943577151, 1913087877, 83908371, 2512341634, 3803740692, 2075208622, 213261112,
96 2463272603, 3855990285, 2094854071, 198958881, 2262029012, 4057260610, 1759359992,
97 534414190, 2176718541, 4139329115, 1873836001, 414664567, 2282248934, 4279200368,
98 1711684554, 285281116, 2405801727, 4167216745, 1634467795, 376229701, 2685067896,
99 3608007406, 1308918612, 956543938, 2808555105, 3495958263, 1231636301, 1047427035,
100 2932959818, 3654703836, 1088359270, 936918000, 2847714899, 3736837829, 1202900863,
101 817233897, 3183342108, 3401237130, 1404277552, 615818150, 3134207493, 3453421203,
102 1423857449, 601450431, 3009837614, 3294710456, 1567103746, 711928724, 3020668471,
103 3272380065, 1510334235, 755167117,
104]
105