Last active
February 10, 2019 18:58
-
-
Save schmee/36e5dd6e60cb91800c794f0f5daa8067 to your computer and use it in GitHub Desktop.
DES bug
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| const assert = @import("std").debug.assert; | |
| const fmt = @import("std").fmt; | |
| const io = @import("std").io; | |
| const math = @import("std").math; | |
| const mem = @import("std").mem; | |
| const os = @import("std").os; | |
| const std = @import("std"); | |
| const warn = @import("std").debug.warn; | |
| const ip = [64]u6{ | |
| 6, 14, 22, 30, 38, 46, 54, 62, | |
| 4, 12, 20, 28, 36, 44, 52, 60, | |
| 2, 10, 18, 26, 34, 42, 50, 58, | |
| 0, 8, 16, 24, 32, 40, 48, 56, | |
| 7, 15, 23, 31, 39, 47, 55, 63, | |
| 5, 13, 21, 29, 37, 45, 53, 61, | |
| 3, 11, 19, 27, 35, 43, 51, 59, | |
| 1, 9, 17, 25, 33, 41, 49, 57, | |
| }; | |
| const fp = [64]u6{ | |
| 24, 56, 16, 48, 8, 40, 0, 32, | |
| 25, 57, 17, 49, 9, 41, 1, 33, | |
| 26, 58, 18, 50, 10, 42, 2, 34, | |
| 27, 59, 19, 51, 11, 43, 3, 35, | |
| 28, 60, 20, 52, 12, 44, 4, 36, | |
| 29, 61, 21, 53, 13, 45, 5, 37, | |
| 30, 62, 22, 54, 14, 46, 6, 38, | |
| 31, 63, 23, 55, 15, 47, 7, 39, | |
| }; | |
| const pc1 = [56]u6{ | |
| 7, 15, 23, 31, 39, 47, 55, 63, | |
| 6, 14, 22, 30, 38, 46, 54, 62, | |
| 5, 13, 21, 29, 37, 45, 53, 61, | |
| 4, 12, 20, 28, 1, 9, 17, 25, | |
| 33, 41, 49, 57, 2, 10, 18, 26, | |
| 34, 42, 50, 58, 3, 11, 19, 27, | |
| 35, 43, 51, 59, 36, 44, 52, 60, | |
| }; | |
| const pc2 = [48]u6{ | |
| 13, 16, 10, 23, 0, 4, 2, 27, | |
| 14, 5, 20, 9, 22, 18, 11, 3, | |
| 25, 7, 15, 6, 26, 19, 12, 1, | |
| 40, 51, 30, 36, 46, 54, 29, 39, | |
| 50, 44, 32, 47, 43, 48, 38, 55, | |
| 33, 52, 45, 41, 49, 35, 28, 31, | |
| }; | |
| const s0 = []u32{ | |
| 0x00410100, 0x00010000, 0x40400000, 0x40410100, 0x00400000, 0x40010100, 0x40010000, 0x40400000, | |
| 0x40010100, 0x00410100, 0x00410000, 0x40000100, 0x40400100, 0x00400000, 0x00000000, 0x40010000, | |
| 0x00010000, 0x40000000, 0x00400100, 0x00010100, 0x40410100, 0x00410000, 0x40000100, 0x00400100, | |
| 0x40000000, 0x00000100, 0x00010100, 0x40410000, 0x00000100, 0x40400100, 0x40410000, 0x00000000, | |
| 0x00000000, 0x40410100, 0x00400100, 0x40010000, 0x00410100, 0x00010000, 0x40000100, 0x00400100, | |
| 0x40410000, 0x00000100, 0x00010100, 0x40400000, 0x40010100, 0x40000000, 0x40400000, 0x00410000, | |
| 0x40410100, 0x00010100, 0x00410000, 0x40400100, 0x00400000, 0x40000100, 0x40010000, 0x00000000, | |
| 0x00010000, 0x00400000, 0x40400100, 0x00410100, 0x40000000, 0x40410000, 0x00000100, 0x40010100, | |
| }; | |
| const s1 = []u32{ | |
| 0x08021002, 0x00000000, 0x00021000, 0x08020000, 0x08000002, 0x00001002, 0x08001000, 0x00021000, | |
| 0x00001000, 0x08020002, 0x00000002, 0x08001000, 0x00020002, 0x08021000, 0x08020000, 0x00000002, | |
| 0x00020000, 0x08001002, 0x08020002, 0x00001000, 0x00021002, 0x08000000, 0x00000000, 0x00020002, | |
| 0x08001002, 0x00021002, 0x08021000, 0x08000002, 0x08000000, 0x00020000, 0x00001002, 0x08021002, | |
| 0x00020002, 0x08021000, 0x08001000, 0x00021002, 0x08021002, 0x00020002, 0x08000002, 0x00000000, | |
| 0x08000000, 0x00001002, 0x00020000, 0x08020002, 0x00001000, 0x08000000, 0x00021002, 0x08001002, | |
| 0x08021000, 0x00001000, 0x00000000, 0x08000002, 0x00000002, 0x08021002, 0x00021000, 0x08020000, | |
| 0x08020002, 0x00020000, 0x00001002, 0x08001000, 0x08001002, 0x00000002, 0x08020000, 0x00021000, | |
| }; | |
| const s2 = []u32{ | |
| 0x20800000, 0x00808020, 0x00000020, 0x20800020, 0x20008000, 0x00800000, 0x20800020, 0x00008020, | |
| 0x00800020, 0x00008000, 0x00808000, 0x20000000, 0x20808020, 0x20000020, 0x20000000, 0x20808000, | |
| 0x00000000, 0x20008000, 0x00808020, 0x00000020, 0x20000020, 0x20808020, 0x00008000, 0x20800000, | |
| 0x20808000, 0x00800020, 0x20008020, 0x00808000, 0x00008020, 0x00000000, 0x00800000, 0x20008020, | |
| 0x00808020, 0x00000020, 0x20000000, 0x00008000, 0x20000020, 0x20008000, 0x00808000, 0x20800020, | |
| 0x00000000, 0x00808020, 0x00008020, 0x20808000, 0x20008000, 0x00800000, 0x20808020, 0x20000000, | |
| 0x20008020, 0x20800000, 0x00800000, 0x20808020, 0x00008000, 0x00800020, 0x20800020, 0x00008020, | |
| 0x00800020, 0x00000000, 0x20808000, 0x20000020, 0x20800000, 0x20008020, 0x00000020, 0x00808000, | |
| }; | |
| const s3 = []u32{ | |
| 0x00080201, 0x02000200, 0x00000001, 0x02080201, 0x00000000, 0x02080000, 0x02000201, 0x00080001, | |
| 0x02080200, 0x02000001, 0x02000000, 0x00000201, 0x02000001, 0x00080201, 0x00080000, 0x02000000, | |
| 0x02080001, 0x00080200, 0x00000200, 0x00000001, 0x00080200, 0x02000201, 0x02080000, 0x00000200, | |
| 0x00000201, 0x00000000, 0x00080001, 0x02080200, 0x02000200, 0x02080001, 0x02080201, 0x00080000, | |
| 0x02080001, 0x00000201, 0x00080000, 0x02000001, 0x00080200, 0x02000200, 0x00000001, 0x02080000, | |
| 0x02000201, 0x00000000, 0x00000200, 0x00080001, 0x00000000, 0x02080001, 0x02080200, 0x00000200, | |
| 0x02000000, 0x02080201, 0x00080201, 0x00080000, 0x02080201, 0x00000001, 0x02000200, 0x00080201, | |
| 0x00080001, 0x00080200, 0x02080000, 0x02000201, 0x00000201, 0x02000000, 0x02000001, 0x02080200, | |
| }; | |
| const s4 = []u32{ | |
| 0x01000000, 0x00002000, 0x00000080, 0x01002084, 0x01002004, 0x01000080, 0x00002084, 0x01002000, | |
| 0x00002000, 0x00000004, 0x01000004, 0x00002080, 0x01000084, 0x01002004, 0x01002080, 0x00000000, | |
| 0x00002080, 0x01000000, 0x00002004, 0x00000084, 0x01000080, 0x00002084, 0x00000000, 0x01000004, | |
| 0x00000004, 0x01000084, 0x01002084, 0x00002004, 0x01002000, 0x00000080, 0x00000084, 0x01002080, | |
| 0x01002080, 0x01000084, 0x00002004, 0x01002000, 0x00002000, 0x00000004, 0x01000004, 0x01000080, | |
| 0x01000000, 0x00002080, 0x01002084, 0x00000000, 0x00002084, 0x01000000, 0x00000080, 0x00002004, | |
| 0x01000084, 0x00000080, 0x00000000, 0x01002084, 0x01002004, 0x01002080, 0x00000084, 0x00002000, | |
| 0x00002080, 0x01002004, 0x01000080, 0x00000084, 0x00000004, 0x00002084, 0x01002000, 0x01000004, | |
| }; | |
| const s5 = []u32{ | |
| 0x10000008, 0x00040008, 0x00000000, 0x10040400, 0x00040008, 0x00000400, 0x10000408, 0x00040000, | |
| 0x00000408, 0x10040408, 0x00040400, 0x10000000, 0x10000400, 0x10000008, 0x10040000, 0x00040408, | |
| 0x00040000, 0x10000408, 0x10040008, 0x00000000, 0x00000400, 0x00000008, 0x10040400, 0x10040008, | |
| 0x10040408, 0x10040000, 0x10000000, 0x00000408, 0x00000008, 0x00040400, 0x00040408, 0x10000400, | |
| 0x00000408, 0x10000000, 0x10000400, 0x00040408, 0x10040400, 0x00040008, 0x00000000, 0x10000400, | |
| 0x10000000, 0x00000400, 0x10040008, 0x00040000, 0x00040008, 0x10040408, 0x00040400, 0x00000008, | |
| 0x10040408, 0x00040400, 0x00040000, 0x10000408, 0x10000008, 0x10040000, 0x00040408, 0x00000000, | |
| 0x00000400, 0x10000008, 0x10000408, 0x10040400, 0x10040000, 0x00000408, 0x00000008, 0x10040008, | |
| }; | |
| const s6 = []u32{ | |
| 0x00000800, 0x00000040, 0x00200040, 0x80200000, 0x80200840, 0x80000800, 0x00000840, 0x00000000, | |
| 0x00200000, 0x80200040, 0x80000040, 0x00200800, 0x80000000, 0x00200840, 0x00200800, 0x80000040, | |
| 0x80200040, 0x00000800, 0x80000800, 0x80200840, 0x00000000, 0x00200040, 0x80200000, 0x00000840, | |
| 0x80200800, 0x80000840, 0x00200840, 0x80000000, 0x80000840, 0x80200800, 0x00000040, 0x00200000, | |
| 0x80000840, 0x00200800, 0x80200800, 0x80000040, 0x00000800, 0x00000040, 0x00200000, 0x80200800, | |
| 0x80200040, 0x80000840, 0x00000840, 0x00000000, 0x00000040, 0x80200000, 0x80000000, 0x00200040, | |
| 0x00000000, 0x80200040, 0x00200040, 0x00000840, 0x80000040, 0x00000800, 0x80200840, 0x00200000, | |
| 0x00200840, 0x80000000, 0x80000800, 0x80200840, 0x80200000, 0x00200840, 0x00200800, 0x80000800, | |
| }; | |
| const s7 = []u32{ | |
| 0x04100010, 0x04104000, 0x00004010, 0x00000000, 0x04004000, 0x00100010, 0x04100000, 0x04104010, | |
| 0x00000010, 0x04000000, 0x00104000, 0x00004010, 0x00104010, 0x04004010, 0x04000010, 0x04100000, | |
| 0x00004000, 0x00104010, 0x00100010, 0x04004000, 0x04104010, 0x04000010, 0x00000000, 0x00104000, | |
| 0x04000000, 0x00100000, 0x04004010, 0x04100010, 0x00100000, 0x00004000, 0x04104000, 0x00000010, | |
| 0x00100000, 0x00004000, 0x04000010, 0x04104010, 0x00004010, 0x04000000, 0x00000000, 0x00104000, | |
| 0x04100010, 0x04004010, 0x04004000, 0x00100010, 0x04104000, 0x00000010, 0x00100010, 0x04004000, | |
| 0x04104010, 0x00100000, 0x04100000, 0x04000010, 0x00104000, 0x00004010, 0x04004010, 0x04100000, | |
| 0x00000010, 0x04104000, 0x00104010, 0x00000000, 0x04000000, 0x04100010, 0x00004000, 0x00104010, | |
| }; | |
| // Has to be var due to https://github.com/ziglang/zig/issues/1766 | |
| var sboxes = [8][64]u32{ s0, s1, s2, s3, s4, s5, s6, s7 }; | |
| fn printAsBinary(value: var) void { | |
| comptime const T = @typeOf(value); | |
| comptime const bits = @typeInfo(T).Int.bits; | |
| comptime const size = @sizeOf(T) * 8; | |
| var buf = []u8{0} ** size; | |
| const result = fmt.bufPrint(buf[0..], "{b}", value) catch unreachable; | |
| var ln = result.len; | |
| var out = []u8{48} ** bits; | |
| for (result) |r, i| { | |
| out[bits - ln + i] = result[i]; | |
| } | |
| warn("{}\n", out); | |
| } | |
| fn rotr(comptime T: type, i: T, amount: math.Log2Int(T)) T { | |
| comptime const TL = @typeOf(amount); | |
| comptime const m = @intCast(TL, @typeInfo(T).Int.bits); | |
| return (i >> amount) | (i << (m - amount)); | |
| } | |
| fn rotl(comptime T: type, i: T, amount: math.Log2Int(T)) T { | |
| comptime const TL = @typeOf(amount); | |
| comptime const m = @typeInfo(T).Int.bits; | |
| const x = @intCast(TL, (m - amount)); | |
| return (i << amount) | (i >> x); | |
| } | |
| fn expand(half: u32) u48 { | |
| const mask: u8 = (u8(1) << 6) - 1; | |
| var i: u5 = 0; | |
| var out: u48 = rotl(u32, half, 1) & mask; | |
| while (i < 7) : (i += 1) { | |
| const piece: u48 = (half >> (3 + (4 * i))) & mask; | |
| out ^= @truncate(u48, (piece << 6 * u6(i + 1))); | |
| } | |
| out ^= (@intCast(u48, half) & 1) << 47; | |
| return out; | |
| } | |
| fn permuteBits(long: var, indices: []const math.Log2Int(@typeOf(long))) @typeOf(long) { | |
| comptime const T = @typeOf(long); | |
| comptime const TL = math.Log2Int(T); | |
| var out: T = 0; | |
| for (indices) |x, i| { | |
| out ^= (((long >> x) & 1) << @intCast(TL, i)); | |
| // Uncomment the line below to make it work! | |
| // warn(""); | |
| } | |
| return out; | |
| } | |
| const shifts = []u5{ | |
| 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1, | |
| }; | |
| fn sbox(long: u48) u32 { | |
| var out: u32 = 0; | |
| for (sboxes) |*box, i| { | |
| const shift: u6 = @intCast(u6, i * 6); | |
| out ^= box.*[@truncate(u6, (long >> shift) & 0b111111)]; | |
| } | |
| return out; | |
| } | |
| pub fn desRounds(keys: []const u48, data: u64, comptime encrypt: bool) u64 { | |
| var perm = permuteBits(data, ip); | |
| var i = u8(0); | |
| var left = @truncate(u32, perm & 0xFFFFFFFF); | |
| var right = @truncate(u32, perm >> 32); | |
| var work: u48 = 0; | |
| var swork: u32 = 0; | |
| while (i < 16) : (i += 1) { | |
| work = expand(right); | |
| work = work ^ keys[if (encrypt) i else (15 - i)]; | |
| swork = sbox(work); | |
| const oldRight = right; | |
| right = left ^ swork; | |
| left = oldRight; | |
| } | |
| var out: u64 = left; | |
| out <<= 32; | |
| out ^= right; | |
| return permuteBits(out, fp[0..]); | |
| } | |
| pub fn subkeys(key: u64) [16]u48 { | |
| const size: u6 = math.maxInt(u6); | |
| var perm = @truncate(u56, permuteBits(key, pc1[0..])); | |
| var left: u28 = @truncate(u28, perm & 0xfffffff); | |
| var right: u28 = @truncate(u28, (perm >> 28) & 0xfffffff); | |
| var subkey: u48 = 0; | |
| var i: u8 = 0; | |
| var keys: [16]u48 = undefined; | |
| while (i < 16) : (i += 1) { | |
| left = rotr(u28, left, shifts[i]); | |
| right = rotr(u28, right, shifts[i]); | |
| var out: u56 = right; | |
| out <<= 28; | |
| out ^= left; | |
| subkey = @truncate(u48, permuteBits(out, pc2[0..])); | |
| keys[i] = subkey; | |
| } | |
| return keys; | |
| } | |
| pub fn desEncryptEcb(key: u64, inData: []const u8, outData: []u64) void { | |
| assert(inData.len % 8 == 0); | |
| var i: u64 = 0; | |
| var offset: u64 = 0; | |
| const keys = subkeys(key); | |
| while (offset <= inData.len - 8) { | |
| // @Speed: avoid this conversion, return [8]u8 from desEncryptTest? | |
| const plain: u64 = mem.readIntSliceBig(u64, inData[offset..(offset + 8)]); | |
| outData[i] = desRounds(keys[0..], plain, true); | |
| i += 1; | |
| offset += 8; | |
| } | |
| } | |
| pub fn desDecryptEcb(key: u64, inData: []const u8, outData: []u64) void { | |
| assert(inData.len % 8 == 0); | |
| var i: u64 = 0; | |
| var offset: u64 = 0; | |
| const keys = subkeys(key); | |
| while (offset <= inData.len - 8) { | |
| // @Speed: avoid this conversion, return [8]u8 from desEncryptTest? | |
| const cipher: u64 = mem.readIntSliceBig(u64, inData[offset..(offset + 8)]); | |
| outData[i] = desRounds(keys[0..], cipher, false); | |
| i += 1; | |
| offset += 8; | |
| } | |
| } | |
| pub fn encryptRandomData() !void { | |
| const testKey: u64 = 0x133457799BBCDFF1; | |
| var da = &std.heap.DirectAllocator.init(); | |
| defer da.deinit(); | |
| var allocator = &da.allocator; | |
| const tmp_file_name = "random_test_data_small.bin"; | |
| // const tmp_file_name = "random_test_data.bin"; | |
| var file = try os.File.openRead(tmp_file_name); | |
| defer file.close(); | |
| var file_in_stream = file.inStream(); | |
| var buf_stream = io.BufferedInStream(os.File.ReadError).init(&file_in_stream.stream); | |
| const st = &buf_stream.stream; | |
| const contents = try st.readAllAlloc(allocator, 3000000 + 1); | |
| // const contents = try st.readAllAlloc(allocator, 300000000 + 1); | |
| defer allocator.free(contents); | |
| var encryptedData = try allocator.alloc(u64, contents.len / 8); | |
| desEncryptEcb(testKey, contents[0..], encryptedData); | |
| { | |
| // const out_file_name = "enc_zig.bin"; | |
| const out_file_name = "enc_zig_small.bin"; | |
| var out_file = try os.File.openWrite(out_file_name); | |
| defer out_file.close(); | |
| var file_out_stream = out_file.outStream(); | |
| var out_buf_stream = io.BufferedOutStream(os.File.WriteError).init(&file_out_stream.stream); | |
| const stt = &out_buf_stream.stream; | |
| warn("begin\n"); | |
| for (encryptedData) |ed| { | |
| try stt.write(mem.asBytes(&@bswap(u64, ed))); | |
| } | |
| // try stt.write(contents); | |
| warn("end\n"); | |
| try out_buf_stream.flush(); | |
| } | |
| } | |
| pub fn main() void { | |
| encryptRandomData() catch unreachable; | |
| } | |
| fn desEncryptTest(key: u64, data: u64) u64 { | |
| const keys = subkeys(key); | |
| return desRounds(keys[0..], data, true); | |
| } | |
| // Taken from: | |
| // https://www.cosic.esat.kuleuven.be/nessie/testvectors/bc/des/Des-64-64.test-vectors | |
| test "test vectors" { | |
| assert(desEncryptTest(0x8000000000000000, 0x0000000000000000) == 0x95A8D72813DAA94D); | |
| assert(desEncryptTest(0x4000000000000000, 0x0000000000000000) == 0x0EEC1487DD8C26D5); | |
| assert(desEncryptTest(0x2000000000000000, 0x0000000000000000) == 0x7AD16FFB79C45926); | |
| assert(desEncryptTest(0x1000000000000000, 0x0000000000000000) == 0xD3746294CA6A6CF3); | |
| assert(desEncryptTest(0x0800000000000000, 0x0000000000000000) == 0x809F5F873C1FD761); | |
| assert(desEncryptTest(0x0400000000000000, 0x0000000000000000) == 0xC02FAFFEC989D1FC); | |
| assert(desEncryptTest(0x0200000000000000, 0x0000000000000000) == 0x4615AA1D33E72F10); | |
| assert(desEncryptTest(0x0100000000000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0080000000000000, 0x0000000000000000) == 0x2055123350C00858); | |
| assert(desEncryptTest(0x0040000000000000, 0x0000000000000000) == 0xDF3B99D6577397C8); | |
| assert(desEncryptTest(0x0020000000000000, 0x0000000000000000) == 0x31FE17369B5288C9); | |
| assert(desEncryptTest(0x0010000000000000, 0x0000000000000000) == 0xDFDD3CC64DAE1642); | |
| assert(desEncryptTest(0x0008000000000000, 0x0000000000000000) == 0x178C83CE2B399D94); | |
| assert(desEncryptTest(0x0004000000000000, 0x0000000000000000) == 0x50F636324A9B7F80); | |
| assert(desEncryptTest(0x0002000000000000, 0x0000000000000000) == 0xA8468EE3BC18F06D); | |
| assert(desEncryptTest(0x0001000000000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000800000000000, 0x0000000000000000) == 0xA2DC9E92FD3CDE92); | |
| assert(desEncryptTest(0x0000400000000000, 0x0000000000000000) == 0xCAC09F797D031287); | |
| assert(desEncryptTest(0x0000200000000000, 0x0000000000000000) == 0x90BA680B22AEB525); | |
| assert(desEncryptTest(0x0000100000000000, 0x0000000000000000) == 0xCE7A24F350E280B6); | |
| assert(desEncryptTest(0x0000080000000000, 0x0000000000000000) == 0x882BFF0AA01A0B87); | |
| assert(desEncryptTest(0x0000040000000000, 0x0000000000000000) == 0x25610288924511C2); | |
| assert(desEncryptTest(0x0000020000000000, 0x0000000000000000) == 0xC71516C29C75D170); | |
| assert(desEncryptTest(0x0000010000000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000008000000000, 0x0000000000000000) == 0x5199C29A52C9F059); | |
| assert(desEncryptTest(0x0000004000000000, 0x0000000000000000) == 0xC22F0A294A71F29F); | |
| assert(desEncryptTest(0x0000002000000000, 0x0000000000000000) == 0xEE371483714C02EA); | |
| assert(desEncryptTest(0x0000001000000000, 0x0000000000000000) == 0xA81FBD448F9E522F); | |
| assert(desEncryptTest(0x0000000800000000, 0x0000000000000000) == 0x4F644C92E192DFED); | |
| assert(desEncryptTest(0x0000000400000000, 0x0000000000000000) == 0x1AFA9A66A6DF92AE); | |
| assert(desEncryptTest(0x0000000200000000, 0x0000000000000000) == 0xB3C1CC715CB879D8); | |
| assert(desEncryptTest(0x0000000100000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000000080000000, 0x0000000000000000) == 0x19D032E64AB0BD8B); | |
| assert(desEncryptTest(0x0000000040000000, 0x0000000000000000) == 0x3CFAA7A7DC8720DC); | |
| assert(desEncryptTest(0x0000000020000000, 0x0000000000000000) == 0xB7265F7F447AC6F3); | |
| assert(desEncryptTest(0x0000000010000000, 0x0000000000000000) == 0x9DB73B3C0D163F54); | |
| assert(desEncryptTest(0x0000000008000000, 0x0000000000000000) == 0x8181B65BABF4A975); | |
| assert(desEncryptTest(0x0000000004000000, 0x0000000000000000) == 0x93C9B64042EAA240); | |
| assert(desEncryptTest(0x0000000002000000, 0x0000000000000000) == 0x5570530829705592); | |
| assert(desEncryptTest(0x0000000001000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000000000800000, 0x0000000000000000) == 0x8638809E878787A0); | |
| assert(desEncryptTest(0x0000000000400000, 0x0000000000000000) == 0x41B9A79AF79AC208); | |
| assert(desEncryptTest(0x0000000000200000, 0x0000000000000000) == 0x7A9BE42F2009A892); | |
| assert(desEncryptTest(0x0000000000100000, 0x0000000000000000) == 0x29038D56BA6D2745); | |
| assert(desEncryptTest(0x0000000000080000, 0x0000000000000000) == 0x5495C6ABF1E5DF51); | |
| assert(desEncryptTest(0x0000000000040000, 0x0000000000000000) == 0xAE13DBD561488933); | |
| assert(desEncryptTest(0x0000000000020000, 0x0000000000000000) == 0x024D1FFA8904E389); | |
| assert(desEncryptTest(0x0000000000010000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000000000008000, 0x0000000000000000) == 0xD1399712F99BF02E); | |
| assert(desEncryptTest(0x0000000000004000, 0x0000000000000000) == 0x14C1D7C1CFFEC79E); | |
| assert(desEncryptTest(0x0000000000002000, 0x0000000000000000) == 0x1DE5279DAE3BED6F); | |
| assert(desEncryptTest(0x0000000000001000, 0x0000000000000000) == 0xE941A33F85501303); | |
| assert(desEncryptTest(0x0000000000000800, 0x0000000000000000) == 0xDA99DBBC9A03F379); | |
| assert(desEncryptTest(0x0000000000000400, 0x0000000000000000) == 0xB7FC92F91D8E92E9); | |
| assert(desEncryptTest(0x0000000000000200, 0x0000000000000000) == 0xAE8E5CAA3CA04E85); | |
| assert(desEncryptTest(0x0000000000000100, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000000000000080, 0x0000000000000000) == 0x9CC62DF43B6EED74); | |
| assert(desEncryptTest(0x0000000000000040, 0x0000000000000000) == 0xD863DBB5C59A91A0); | |
| assert(desEncryptTest(0x0000000000000020, 0x0000000000000000) == 0xA1AB2190545B91D7); | |
| assert(desEncryptTest(0x0000000000000010, 0x0000000000000000) == 0x0875041E64C570F7); | |
| assert(desEncryptTest(0x0000000000000008, 0x0000000000000000) == 0x5A594528BEBEF1CC); | |
| assert(desEncryptTest(0x0000000000000004, 0x0000000000000000) == 0xFCDB3291DE21F0C0); | |
| assert(desEncryptTest(0x0000000000000002, 0x0000000000000000) == 0x869EFD7F9F265A09); | |
| assert(desEncryptTest(0x0000000000000001, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0000000000000000, 0x8000000000000000) == 0x95F8A5E5DD31D900); | |
| assert(desEncryptTest(0x0000000000000000, 0x4000000000000000) == 0xDD7F121CA5015619); | |
| assert(desEncryptTest(0x0000000000000000, 0x2000000000000000) == 0x2E8653104F3834EA); | |
| assert(desEncryptTest(0x0000000000000000, 0x1000000000000000) == 0x4BD388FF6CD81D4F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0800000000000000) == 0x20B9E767B2FB1456); | |
| assert(desEncryptTest(0x0000000000000000, 0x0400000000000000) == 0x55579380D77138EF); | |
| assert(desEncryptTest(0x0000000000000000, 0x0200000000000000) == 0x6CC5DEFAAF04512F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0100000000000000) == 0x0D9F279BA5D87260); | |
| assert(desEncryptTest(0x0000000000000000, 0x0080000000000000) == 0xD9031B0271BD5A0A); | |
| assert(desEncryptTest(0x0000000000000000, 0x0040000000000000) == 0x424250B37C3DD951); | |
| assert(desEncryptTest(0x0000000000000000, 0x0020000000000000) == 0xB8061B7ECD9A21E5); | |
| assert(desEncryptTest(0x0000000000000000, 0x0010000000000000) == 0xF15D0F286B65BD28); | |
| assert(desEncryptTest(0x0000000000000000, 0x0008000000000000) == 0xADD0CC8D6E5DEBA1); | |
| assert(desEncryptTest(0x0000000000000000, 0x0004000000000000) == 0xE6D5F82752AD63D1); | |
| assert(desEncryptTest(0x0000000000000000, 0x0002000000000000) == 0xECBFE3BD3F591A5E); | |
| assert(desEncryptTest(0x0000000000000000, 0x0001000000000000) == 0xF356834379D165CD); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000800000000000) == 0x2B9F982F20037FA9); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000400000000000) == 0x889DE068A16F0BE6); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000200000000000) == 0xE19E275D846A1298); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000100000000000) == 0x329A8ED523D71AEC); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000080000000000) == 0xE7FCE22557D23C97); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000040000000000) == 0x12A9F5817FF2D65D); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000020000000000) == 0xA484C3AD38DC9C19); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000010000000000) == 0xFBE00A8A1EF8AD72); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000008000000000) == 0x750D079407521363); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000004000000000) == 0x64FEED9C724C2FAF); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000002000000000) == 0xF02B263B328E2B60); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000001000000000) == 0x9D64555A9A10B852); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000800000000) == 0xD106FF0BED5255D7); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000400000000) == 0xE1652C6B138C64A5); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000200000000) == 0xE428581186EC8F46); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000100000000) == 0xAEB5F5EDE22D1A36); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000080000000) == 0xE943D7568AEC0C5C); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000040000000) == 0xDF98C8276F54B04B); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000020000000) == 0xB160E4680F6C696F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000010000000) == 0xFA0752B07D9C4AB8); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000008000000) == 0xCA3A2B036DBC8502); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000004000000) == 0x5E0905517BB59BCF); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000002000000) == 0x814EEB3B91D90726); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000001000000) == 0x4D49DB1532919C9F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000800000) == 0x25EB5FC3F8CF0621); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000400000) == 0xAB6A20C0620D1C6F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000200000) == 0x79E90DBC98F92CCA); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000100000) == 0x866ECEDD8072BB0E); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000080000) == 0x8B54536F2F3E64A8); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000040000) == 0xEA51D3975595B86B); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000020000) == 0xCAFFC6AC4542DE31); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000010000) == 0x8DD45A2DDF90796C); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000008000) == 0x1029D55E880EC2D0); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000004000) == 0x5D86CB23639DBEA9); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000002000) == 0x1D1CA853AE7C0C5F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000001000) == 0xCE332329248F3228); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000800) == 0x8405D1ABE24FB942); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000400) == 0xE643D78090CA4207); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000200) == 0x48221B9937748A23); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000100) == 0xDD7C0BBD61FAFD54); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000080) == 0x2FBC291A570DB5C4); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000040) == 0xE07C30D7E4E26E12); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000020) == 0x0953E2258E8E90A1); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000010) == 0x5B711BC4CEEBF2EE); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000008) == 0xCC083F1E6D9E85F6); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000004) == 0xD2FD8867D50D2DFE); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000002) == 0x06E7EA22CE92708F); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000001) == 0x166B40B44ABA4BD6); | |
| assert(desEncryptTest(0x0000000000000000, 0x0000000000000000) == 0x8CA64DE9C1B123A7); | |
| assert(desEncryptTest(0x0101010101010101, 0x0101010101010101) == 0x994D4DC157B96C52); | |
| assert(desEncryptTest(0x0202020202020202, 0x0202020202020202) == 0xE127C2B61D98E6E2); | |
| assert(desEncryptTest(0x0303030303030303, 0x0303030303030303) == 0x984C91D78A269CE3); | |
| assert(desEncryptTest(0x0404040404040404, 0x0404040404040404) == 0x1F4570BB77550683); | |
| assert(desEncryptTest(0x0505050505050505, 0x0505050505050505) == 0x3990ABF98D672B16); | |
| assert(desEncryptTest(0x0606060606060606, 0x0606060606060606) == 0x3F5150BBA081D585); | |
| assert(desEncryptTest(0x0707070707070707, 0x0707070707070707) == 0xC65242248C9CF6F2); | |
| assert(desEncryptTest(0x0808080808080808, 0x0808080808080808) == 0x10772D40FAD24257); | |
| assert(desEncryptTest(0x0909090909090909, 0x0909090909090909) == 0xF0139440647A6E7B); | |
| assert(desEncryptTest(0x0A0A0A0A0A0A0A0A, 0x0A0A0A0A0A0A0A0A) == 0x0A288603044D740C); | |
| assert(desEncryptTest(0x0B0B0B0B0B0B0B0B, 0x0B0B0B0B0B0B0B0B) == 0x6359916942F7438F); | |
| assert(desEncryptTest(0x0C0C0C0C0C0C0C0C, 0x0C0C0C0C0C0C0C0C) == 0x934316AE443CF08B); | |
| assert(desEncryptTest(0x0D0D0D0D0D0D0D0D, 0x0D0D0D0D0D0D0D0D) == 0xE3F56D7F1130A2B7); | |
| assert(desEncryptTest(0x0E0E0E0E0E0E0E0E, 0x0E0E0E0E0E0E0E0E) == 0xA2E4705087C6B6B4); | |
| assert(desEncryptTest(0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F) == 0xD5D76E09A447E8C3); | |
| assert(desEncryptTest(0x1010101010101010, 0x1010101010101010) == 0xDD7515F2BFC17F85); | |
| assert(desEncryptTest(0x1111111111111111, 0x1111111111111111) == 0xF40379AB9E0EC533); | |
| assert(desEncryptTest(0x1212121212121212, 0x1212121212121212) == 0x96CD27784D1563E5); | |
| assert(desEncryptTest(0x1313131313131313, 0x1313131313131313) == 0x2911CF5E94D33FE1); | |
| assert(desEncryptTest(0x1414141414141414, 0x1414141414141414) == 0x377B7F7CA3E5BBB3); | |
| assert(desEncryptTest(0x1515151515151515, 0x1515151515151515) == 0x701AA63832905A92); | |
| assert(desEncryptTest(0x1616161616161616, 0x1616161616161616) == 0x2006E716C4252D6D); | |
| assert(desEncryptTest(0x1717171717171717, 0x1717171717171717) == 0x452C1197422469F8); | |
| assert(desEncryptTest(0x1818181818181818, 0x1818181818181818) == 0xC33FD1EB49CB64DA); | |
| assert(desEncryptTest(0x1919191919191919, 0x1919191919191919) == 0x7572278F364EB50D); | |
| assert(desEncryptTest(0x1A1A1A1A1A1A1A1A, 0x1A1A1A1A1A1A1A1A) == 0x69E51488403EF4C3); | |
| assert(desEncryptTest(0x1B1B1B1B1B1B1B1B, 0x1B1B1B1B1B1B1B1B) == 0xFF847E0ADF192825); | |
| assert(desEncryptTest(0x1C1C1C1C1C1C1C1C, 0x1C1C1C1C1C1C1C1C) == 0x521B7FB3B41BB791); | |
| assert(desEncryptTest(0x1D1D1D1D1D1D1D1D, 0x1D1D1D1D1D1D1D1D) == 0x26059A6A0F3F6B35); | |
| assert(desEncryptTest(0x1E1E1E1E1E1E1E1E, 0x1E1E1E1E1E1E1E1E) == 0xF24A8D2231C77538); | |
| assert(desEncryptTest(0x1F1F1F1F1F1F1F1F, 0x1F1F1F1F1F1F1F1F) == 0x4FD96EC0D3304EF6); | |
| assert(desEncryptTest(0x2020202020202020, 0x2020202020202020) == 0x18A9D580A900B699); | |
| assert(desEncryptTest(0x2121212121212121, 0x2121212121212121) == 0x88586E1D755B9B5A); | |
| assert(desEncryptTest(0x2222222222222222, 0x2222222222222222) == 0x0F8ADFFB11DC2784); | |
| assert(desEncryptTest(0x2323232323232323, 0x2323232323232323) == 0x2F30446C8312404A); | |
| assert(desEncryptTest(0x2424242424242424, 0x2424242424242424) == 0x0BA03D9E6C196511); | |
| assert(desEncryptTest(0x2525252525252525, 0x2525252525252525) == 0x3E55E997611E4B7D); | |
| assert(desEncryptTest(0x2626262626262626, 0x2626262626262626) == 0xB2522FB5F158F0DF); | |
| assert(desEncryptTest(0x2727272727272727, 0x2727272727272727) == 0x2109425935406AB8); | |
| assert(desEncryptTest(0x2828282828282828, 0x2828282828282828) == 0x11A16028F310FF16); | |
| assert(desEncryptTest(0x2929292929292929, 0x2929292929292929) == 0x73F0C45F379FE67F); | |
| assert(desEncryptTest(0x2A2A2A2A2A2A2A2A, 0x2A2A2A2A2A2A2A2A) == 0xDCAD4338F7523816); | |
| assert(desEncryptTest(0x2B2B2B2B2B2B2B2B, 0x2B2B2B2B2B2B2B2B) == 0xB81634C1CEAB298C); | |
| assert(desEncryptTest(0x2C2C2C2C2C2C2C2C, 0x2C2C2C2C2C2C2C2C) == 0xDD2CCB29B6C4C349); | |
| assert(desEncryptTest(0x2D2D2D2D2D2D2D2D, 0x2D2D2D2D2D2D2D2D) == 0x7D07A77A2ABD50A7); | |
| assert(desEncryptTest(0x2E2E2E2E2E2E2E2E, 0x2E2E2E2E2E2E2E2E) == 0x30C1B0C1FD91D371); | |
| assert(desEncryptTest(0x2F2F2F2F2F2F2F2F, 0x2F2F2F2F2F2F2F2F) == 0xC4427B31AC61973B); | |
| assert(desEncryptTest(0x3030303030303030, 0x3030303030303030) == 0xF47BB46273B15EB5); | |
| assert(desEncryptTest(0x3131313131313131, 0x3131313131313131) == 0x655EA628CF62585F); | |
| assert(desEncryptTest(0x3232323232323232, 0x3232323232323232) == 0xAC978C247863388F); | |
| assert(desEncryptTest(0x3333333333333333, 0x3333333333333333) == 0x0432ED386F2DE328); | |
| assert(desEncryptTest(0x3434343434343434, 0x3434343434343434) == 0xD254014CB986B3C2); | |
| assert(desEncryptTest(0x3535353535353535, 0x3535353535353535) == 0xB256E34BEDB49801); | |
| assert(desEncryptTest(0x3636363636363636, 0x3636363636363636) == 0x37F8759EB77E7BFC); | |
| assert(desEncryptTest(0x3737373737373737, 0x3737373737373737) == 0x5013CA4F62C9CEA0); | |
| assert(desEncryptTest(0x3838383838383838, 0x3838383838383838) == 0x8940F7B3EACA5939); | |
| assert(desEncryptTest(0x3939393939393939, 0x3939393939393939) == 0xE22B19A55086774B); | |
| assert(desEncryptTest(0x3A3A3A3A3A3A3A3A, 0x3A3A3A3A3A3A3A3A) == 0xB04A2AAC925ABB0B); | |
| assert(desEncryptTest(0x3B3B3B3B3B3B3B3B, 0x3B3B3B3B3B3B3B3B) == 0x8D250D58361597FC); | |
| assert(desEncryptTest(0x3C3C3C3C3C3C3C3C, 0x3C3C3C3C3C3C3C3C) == 0x51F0114FB6A6CD37); | |
| assert(desEncryptTest(0x3D3D3D3D3D3D3D3D, 0x3D3D3D3D3D3D3D3D) == 0x9D0BB4DB830ECB73); | |
| assert(desEncryptTest(0x3E3E3E3E3E3E3E3E, 0x3E3E3E3E3E3E3E3E) == 0xE96089D6368F3E1A); | |
| assert(desEncryptTest(0x3F3F3F3F3F3F3F3F, 0x3F3F3F3F3F3F3F3F) == 0x5C4CA877A4E1E92D); | |
| assert(desEncryptTest(0x4040404040404040, 0x4040404040404040) == 0x6D55DDBC8DEA95FF); | |
| assert(desEncryptTest(0x4141414141414141, 0x4141414141414141) == 0x19DF84AC95551003); | |
| assert(desEncryptTest(0x4242424242424242, 0x4242424242424242) == 0x724E7332696D08A7); | |
| assert(desEncryptTest(0x4343434343434343, 0x4343434343434343) == 0xB91810B8CDC58FE2); | |
| assert(desEncryptTest(0x4444444444444444, 0x4444444444444444) == 0x06E23526EDCCD0C4); | |
| assert(desEncryptTest(0x4545454545454545, 0x4545454545454545) == 0xEF52491D5468D441); | |
| assert(desEncryptTest(0x4646464646464646, 0x4646464646464646) == 0x48019C59E39B90C5); | |
| assert(desEncryptTest(0x4747474747474747, 0x4747474747474747) == 0x0544083FB902D8C0); | |
| assert(desEncryptTest(0x4848484848484848, 0x4848484848484848) == 0x63B15CADA668CE12); | |
| assert(desEncryptTest(0x4949494949494949, 0x4949494949494949) == 0xEACC0C1264171071); | |
| assert(desEncryptTest(0x4A4A4A4A4A4A4A4A, 0x4A4A4A4A4A4A4A4A) == 0x9D2B8C0AC605F274); | |
| assert(desEncryptTest(0x4B4B4B4B4B4B4B4B, 0x4B4B4B4B4B4B4B4B) == 0xC90F2F4C98A8FB2A); | |
| assert(desEncryptTest(0x4C4C4C4C4C4C4C4C, 0x4C4C4C4C4C4C4C4C) == 0x03481B4828FD1D04); | |
| assert(desEncryptTest(0x4D4D4D4D4D4D4D4D, 0x4D4D4D4D4D4D4D4D) == 0xC78FC45A1DCEA2E2); | |
| assert(desEncryptTest(0x4E4E4E4E4E4E4E4E, 0x4E4E4E4E4E4E4E4E) == 0xDB96D88C3460D801); | |
| assert(desEncryptTest(0x4F4F4F4F4F4F4F4F, 0x4F4F4F4F4F4F4F4F) == 0x6C69E720F5105518); | |
| assert(desEncryptTest(0x5050505050505050, 0x5050505050505050) == 0x0D262E418BC893F3); | |
| assert(desEncryptTest(0x5151515151515151, 0x5151515151515151) == 0x6AD84FD7848A0A5C); | |
| assert(desEncryptTest(0x5252525252525252, 0x5252525252525252) == 0xC365CB35B34B6114); | |
| assert(desEncryptTest(0x5353535353535353, 0x5353535353535353) == 0x1155392E877F42A9); | |
| assert(desEncryptTest(0x5454545454545454, 0x5454545454545454) == 0x531BE5F9405DA715); | |
| assert(desEncryptTest(0x5555555555555555, 0x5555555555555555) == 0x3BCDD41E6165A5E8); | |
| assert(desEncryptTest(0x5656565656565656, 0x5656565656565656) == 0x2B1FF5610A19270C); | |
| assert(desEncryptTest(0x5757575757575757, 0x5757575757575757) == 0xD90772CF3F047CFD); | |
| assert(desEncryptTest(0x5858585858585858, 0x5858585858585858) == 0x1BEA27FFB72457B7); | |
| assert(desEncryptTest(0x5959595959595959, 0x5959595959595959) == 0x85C3E0C429F34C27); | |
| assert(desEncryptTest(0x5A5A5A5A5A5A5A5A, 0x5A5A5A5A5A5A5A5A) == 0xF9038021E37C7618); | |
| assert(desEncryptTest(0x5B5B5B5B5B5B5B5B, 0x5B5B5B5B5B5B5B5B) == 0x35BC6FF838DBA32F); | |
| assert(desEncryptTest(0x5C5C5C5C5C5C5C5C, 0x5C5C5C5C5C5C5C5C) == 0x4927ACC8CE45ECE7); | |
| assert(desEncryptTest(0x5D5D5D5D5D5D5D5D, 0x5D5D5D5D5D5D5D5D) == 0xE812EE6E3572985C); | |
| assert(desEncryptTest(0x5E5E5E5E5E5E5E5E, 0x5E5E5E5E5E5E5E5E) == 0x9BB93A89627BF65F); | |
| assert(desEncryptTest(0x5F5F5F5F5F5F5F5F, 0x5F5F5F5F5F5F5F5F) == 0xEF12476884CB74CA); | |
| assert(desEncryptTest(0x6060606060606060, 0x6060606060606060) == 0x1BF17E00C09E7CBF); | |
| assert(desEncryptTest(0x6161616161616161, 0x6161616161616161) == 0x29932350C098DB5D); | |
| assert(desEncryptTest(0x6262626262626262, 0x6262626262626262) == 0xB476E6499842AC54); | |
| assert(desEncryptTest(0x6363636363636363, 0x6363636363636363) == 0x5C662C29C1E96056); | |
| assert(desEncryptTest(0x6464646464646464, 0x6464646464646464) == 0x3AF1703D76442789); | |
| assert(desEncryptTest(0x6565656565656565, 0x6565656565656565) == 0x86405D9B425A8C8C); | |
| assert(desEncryptTest(0x6666666666666666, 0x6666666666666666) == 0xEBBF4810619C2C55); | |
| assert(desEncryptTest(0x6767676767676767, 0x6767676767676767) == 0xF8D1CD7367B21B5D); | |
| assert(desEncryptTest(0x6868686868686868, 0x6868686868686868) == 0x9EE703142BF8D7E2); | |
| assert(desEncryptTest(0x6969696969696969, 0x6969696969696969) == 0x5FDFFFC3AAAB0CB3); | |
| assert(desEncryptTest(0x6A6A6A6A6A6A6A6A, 0x6A6A6A6A6A6A6A6A) == 0x26C940AB13574231); | |
| assert(desEncryptTest(0x6B6B6B6B6B6B6B6B, 0x6B6B6B6B6B6B6B6B) == 0x1E2DC77E36A84693); | |
| assert(desEncryptTest(0x6C6C6C6C6C6C6C6C, 0x6C6C6C6C6C6C6C6C) == 0x0F4FF4D9BC7E2244); | |
| assert(desEncryptTest(0x6D6D6D6D6D6D6D6D, 0x6D6D6D6D6D6D6D6D) == 0xA4C9A0D04D3280CD); | |
| assert(desEncryptTest(0x6E6E6E6E6E6E6E6E, 0x6E6E6E6E6E6E6E6E) == 0x9FAF2C96FE84919D); | |
| assert(desEncryptTest(0x6F6F6F6F6F6F6F6F, 0x6F6F6F6F6F6F6F6F) == 0x115DBC965E6096C8); | |
| assert(desEncryptTest(0x7070707070707070, 0x7070707070707070) == 0xAF531E9520994017); | |
| assert(desEncryptTest(0x7171717171717171, 0x7171717171717171) == 0xB971ADE70E5C89EE); | |
| assert(desEncryptTest(0x7272727272727272, 0x7272727272727272) == 0x415D81C86AF9C376); | |
| assert(desEncryptTest(0x7373737373737373, 0x7373737373737373) == 0x8DFB864FDB3C6811); | |
| assert(desEncryptTest(0x7474747474747474, 0x7474747474747474) == 0x10B1C170E3398F91); | |
| assert(desEncryptTest(0x7575757575757575, 0x7575757575757575) == 0xCFEF7A1C0218DB1E); | |
| assert(desEncryptTest(0x7676767676767676, 0x7676767676767676) == 0xDBAC30A2A40B1B9C); | |
| assert(desEncryptTest(0x7777777777777777, 0x7777777777777777) == 0x89D3BF37052162E9); | |
| assert(desEncryptTest(0x7878787878787878, 0x7878787878787878) == 0x80D9230BDAEB67DC); | |
| assert(desEncryptTest(0x7979797979797979, 0x7979797979797979) == 0x3440911019AD68D7); | |
| assert(desEncryptTest(0x7A7A7A7A7A7A7A7A, 0x7A7A7A7A7A7A7A7A) == 0x9626FE57596E199E); | |
| assert(desEncryptTest(0x7B7B7B7B7B7B7B7B, 0x7B7B7B7B7B7B7B7B) == 0xDEA0B796624BB5BA); | |
| assert(desEncryptTest(0x7C7C7C7C7C7C7C7C, 0x7C7C7C7C7C7C7C7C) == 0xE9E40542BDDB3E9D); | |
| assert(desEncryptTest(0x7D7D7D7D7D7D7D7D, 0x7D7D7D7D7D7D7D7D) == 0x8AD99914B354B911); | |
| assert(desEncryptTest(0x7E7E7E7E7E7E7E7E, 0x7E7E7E7E7E7E7E7E) == 0x6F85B98DD12CB13B); | |
| assert(desEncryptTest(0x7F7F7F7F7F7F7F7F, 0x7F7F7F7F7F7F7F7F) == 0x10130DA3C3A23924); | |
| assert(desEncryptTest(0x8080808080808080, 0x8080808080808080) == 0xEFECF25C3C5DC6DB); | |
| assert(desEncryptTest(0x8181818181818181, 0x8181818181818181) == 0x907A46722ED34EC4); | |
| assert(desEncryptTest(0x8282828282828282, 0x8282828282828282) == 0x752666EB4CAB46EE); | |
| assert(desEncryptTest(0x8383838383838383, 0x8383838383838383) == 0x161BFABD4224C162); | |
| assert(desEncryptTest(0x8484848484848484, 0x8484848484848484) == 0x215F48699DB44A45); | |
| assert(desEncryptTest(0x8585858585858585, 0x8585858585858585) == 0x69D901A8A691E661); | |
| assert(desEncryptTest(0x8686868686868686, 0x8686868686868686) == 0xCBBF6EEFE6529728); | |
| assert(desEncryptTest(0x8787878787878787, 0x8787878787878787) == 0x7F26DCF425149823); | |
| assert(desEncryptTest(0x8888888888888888, 0x8888888888888888) == 0x762C40C8FADE9D16); | |
| assert(desEncryptTest(0x8989898989898989, 0x8989898989898989) == 0x2453CF5D5BF4E463); | |
| assert(desEncryptTest(0x8A8A8A8A8A8A8A8A, 0x8A8A8A8A8A8A8A8A) == 0x301085E3FDE724E1); | |
| assert(desEncryptTest(0x8B8B8B8B8B8B8B8B, 0x8B8B8B8B8B8B8B8B) == 0xEF4E3E8F1CC6706E); | |
| assert(desEncryptTest(0x8C8C8C8C8C8C8C8C, 0x8C8C8C8C8C8C8C8C) == 0x720479B024C397EE); | |
| assert(desEncryptTest(0x8D8D8D8D8D8D8D8D, 0x8D8D8D8D8D8D8D8D) == 0xBEA27E3795063C89); | |
| assert(desEncryptTest(0x8E8E8E8E8E8E8E8E, 0x8E8E8E8E8E8E8E8E) == 0x468E5218F1A37611); | |
| assert(desEncryptTest(0x8F8F8F8F8F8F8F8F, 0x8F8F8F8F8F8F8F8F) == 0x50ACE16ADF66BFE8); | |
| assert(desEncryptTest(0x9090909090909090, 0x9090909090909090) == 0xEEA24369A19F6937); | |
| assert(desEncryptTest(0x9191919191919191, 0x9191919191919191) == 0x6050D369017B6E62); | |
| assert(desEncryptTest(0x9292929292929292, 0x9292929292929292) == 0x5B365F2FB2CD7F32); | |
| assert(desEncryptTest(0x9393939393939393, 0x9393939393939393) == 0xF0B00B264381DDBB); | |
| assert(desEncryptTest(0x9494949494949494, 0x9494949494949494) == 0xE1D23881C957B96C); | |
| assert(desEncryptTest(0x9595959595959595, 0x9595959595959595) == 0xD936BF54ECA8BDCE); | |
| assert(desEncryptTest(0x9696969696969696, 0x9696969696969696) == 0xA020003C5554F34C); | |
| assert(desEncryptTest(0x9797979797979797, 0x9797979797979797) == 0x6118FCEBD407281D); | |
| assert(desEncryptTest(0x9898989898989898, 0x9898989898989898) == 0x072E328C984DE4A2); | |
| assert(desEncryptTest(0x9999999999999999, 0x9999999999999999) == 0x1440B7EF9E63D3AA); | |
| assert(desEncryptTest(0x9A9A9A9A9A9A9A9A, 0x9A9A9A9A9A9A9A9A) == 0x79BFA264BDA57373); | |
| assert(desEncryptTest(0x9B9B9B9B9B9B9B9B, 0x9B9B9B9B9B9B9B9B) == 0xC50E8FC289BBD876); | |
| assert(desEncryptTest(0x9C9C9C9C9C9C9C9C, 0x9C9C9C9C9C9C9C9C) == 0xA399D3D63E169FA9); | |
| assert(desEncryptTest(0x9D9D9D9D9D9D9D9D, 0x9D9D9D9D9D9D9D9D) == 0x4B8919B667BD53AB); | |
| assert(desEncryptTest(0x9E9E9E9E9E9E9E9E, 0x9E9E9E9E9E9E9E9E) == 0xD66CDCAF3F6724A2); | |
| assert(desEncryptTest(0x9F9F9F9F9F9F9F9F, 0x9F9F9F9F9F9F9F9F) == 0xE40E81FF3F618340); | |
| assert(desEncryptTest(0xA0A0A0A0A0A0A0A0, 0xA0A0A0A0A0A0A0A0) == 0x10EDB8977B348B35); | |
| assert(desEncryptTest(0xA1A1A1A1A1A1A1A1, 0xA1A1A1A1A1A1A1A1) == 0x6446C5769D8409A0); | |
| assert(desEncryptTest(0xA2A2A2A2A2A2A2A2, 0xA2A2A2A2A2A2A2A2) == 0x17ED1191CA8D67A3); | |
| assert(desEncryptTest(0xA3A3A3A3A3A3A3A3, 0xA3A3A3A3A3A3A3A3) == 0xB6D8533731BA1318); | |
| assert(desEncryptTest(0xA4A4A4A4A4A4A4A4, 0xA4A4A4A4A4A4A4A4) == 0xCA439007C7245CD0); | |
| assert(desEncryptTest(0xA5A5A5A5A5A5A5A5, 0xA5A5A5A5A5A5A5A5) == 0x06FC7FDE1C8389E7); | |
| assert(desEncryptTest(0xA6A6A6A6A6A6A6A6, 0xA6A6A6A6A6A6A6A6) == 0x7A3C1F3BD60CB3D8); | |
| assert(desEncryptTest(0xA7A7A7A7A7A7A7A7, 0xA7A7A7A7A7A7A7A7) == 0xE415D80048DBA848); | |
| assert(desEncryptTest(0xA8A8A8A8A8A8A8A8, 0xA8A8A8A8A8A8A8A8) == 0x26F88D30C0FB8302); | |
| assert(desEncryptTest(0xA9A9A9A9A9A9A9A9, 0xA9A9A9A9A9A9A9A9) == 0xD4E00A9EF5E6D8F3); | |
| assert(desEncryptTest(0xAAAAAAAAAAAAAAAA, 0xAAAAAAAAAAAAAAAA) == 0xC4322BE19E9A5A17); | |
| assert(desEncryptTest(0xABABABABABABABAB, 0xABABABABABABABAB) == 0xACE41A06BFA258EA); | |
| assert(desEncryptTest(0xACACACACACACACAC, 0xACACACACACACACAC) == 0xEEAAC6D17880BD56); | |
| assert(desEncryptTest(0xADADADADADADADAD, 0xADADADADADADADAD) == 0x3C9A34CA4CB49EEB); | |
| assert(desEncryptTest(0xAEAEAEAEAEAEAEAE, 0xAEAEAEAEAEAEAEAE) == 0x9527B0287B75F5A3); | |
| assert(desEncryptTest(0xAFAFAFAFAFAFAFAF, 0xAFAFAFAFAFAFAFAF) == 0xF2D9D1BE74376C0C); | |
| assert(desEncryptTest(0xB0B0B0B0B0B0B0B0, 0xB0B0B0B0B0B0B0B0) == 0x939618DF0AEFAAE7); | |
| assert(desEncryptTest(0xB1B1B1B1B1B1B1B1, 0xB1B1B1B1B1B1B1B1) == 0x24692773CB9F27FE); | |
| assert(desEncryptTest(0xB2B2B2B2B2B2B2B2, 0xB2B2B2B2B2B2B2B2) == 0x38703BA5E2315D1D); | |
| assert(desEncryptTest(0xB3B3B3B3B3B3B3B3, 0xB3B3B3B3B3B3B3B3) == 0xFCB7E4B7D702E2FB); | |
| assert(desEncryptTest(0xB4B4B4B4B4B4B4B4, 0xB4B4B4B4B4B4B4B4) == 0x36F0D0B3675704D5); | |
| assert(desEncryptTest(0xB5B5B5B5B5B5B5B5, 0xB5B5B5B5B5B5B5B5) == 0x62D473F539FA0D8B); | |
| assert(desEncryptTest(0xB6B6B6B6B6B6B6B6, 0xB6B6B6B6B6B6B6B6) == 0x1533F3ED9BE8EF8E); | |
| assert(desEncryptTest(0xB7B7B7B7B7B7B7B7, 0xB7B7B7B7B7B7B7B7) == 0x9C4EA352599731ED); | |
| assert(desEncryptTest(0xB8B8B8B8B8B8B8B8, 0xB8B8B8B8B8B8B8B8) == 0xFABBF7C046FD273F); | |
| assert(desEncryptTest(0xB9B9B9B9B9B9B9B9, 0xB9B9B9B9B9B9B9B9) == 0xB7FE63A61C646F3A); | |
| assert(desEncryptTest(0xBABABABABABABABA, 0xBABABABABABABABA) == 0x10ADB6E2AB972BBE); | |
| assert(desEncryptTest(0xBBBBBBBBBBBBBBBB, 0xBBBBBBBBBBBBBBBB) == 0xF91DCAD912332F3B); | |
| assert(desEncryptTest(0xBCBCBCBCBCBCBCBC, 0xBCBCBCBCBCBCBCBC) == 0x46E7EF47323A701D); | |
| assert(desEncryptTest(0xBDBDBDBDBDBDBDBD, 0xBDBDBDBDBDBDBDBD) == 0x8DB18CCD9692F758); | |
| assert(desEncryptTest(0xBEBEBEBEBEBEBEBE, 0xBEBEBEBEBEBEBEBE) == 0xE6207B536AAAEFFC); | |
| assert(desEncryptTest(0xBFBFBFBFBFBFBFBF, 0xBFBFBFBFBFBFBFBF) == 0x92AA224372156A00); | |
| assert(desEncryptTest(0xC0C0C0C0C0C0C0C0, 0xC0C0C0C0C0C0C0C0) == 0xA3B357885B1E16D2); | |
| assert(desEncryptTest(0xC1C1C1C1C1C1C1C1, 0xC1C1C1C1C1C1C1C1) == 0x169F7629C970C1E5); | |
| assert(desEncryptTest(0xC2C2C2C2C2C2C2C2, 0xC2C2C2C2C2C2C2C2) == 0x62F44B247CF1348C); | |
| assert(desEncryptTest(0xC3C3C3C3C3C3C3C3, 0xC3C3C3C3C3C3C3C3) == 0xAE0FEEB0495932C8); | |
| assert(desEncryptTest(0xC4C4C4C4C4C4C4C4, 0xC4C4C4C4C4C4C4C4) == 0x72DAF2A7C9EA6803); | |
| assert(desEncryptTest(0xC5C5C5C5C5C5C5C5, 0xC5C5C5C5C5C5C5C5) == 0x4FB5D5536DA544F4); | |
| assert(desEncryptTest(0xC6C6C6C6C6C6C6C6, 0xC6C6C6C6C6C6C6C6) == 0x1DD4E65AAF7988B4); | |
| assert(desEncryptTest(0xC7C7C7C7C7C7C7C7, 0xC7C7C7C7C7C7C7C7) == 0x76BF084C1535A6C6); | |
| assert(desEncryptTest(0xC8C8C8C8C8C8C8C8, 0xC8C8C8C8C8C8C8C8) == 0xAFEC35B09D36315F); | |
| assert(desEncryptTest(0xC9C9C9C9C9C9C9C9, 0xC9C9C9C9C9C9C9C9) == 0xC8078A6148818403); | |
| assert(desEncryptTest(0xCACACACACACACACA, 0xCACACACACACACACA) == 0x4DA91CB4124B67FE); | |
| assert(desEncryptTest(0xCBCBCBCBCBCBCBCB, 0xCBCBCBCBCBCBCBCB) == 0x2DABFEB346794C3D); | |
| assert(desEncryptTest(0xCCCCCCCCCCCCCCCC, 0xCCCCCCCCCCCCCCCC) == 0xFBCD12C790D21CD7); | |
| assert(desEncryptTest(0xCDCDCDCDCDCDCDCD, 0xCDCDCDCDCDCDCDCD) == 0x536873DB879CC770); | |
| assert(desEncryptTest(0xCECECECECECECECE, 0xCECECECECECECECE) == 0x9AA159D7309DA7A0); | |
| assert(desEncryptTest(0xCFCFCFCFCFCFCFCF, 0xCFCFCFCFCFCFCFCF) == 0x0B844B9D8C4EA14A); | |
| assert(desEncryptTest(0xD0D0D0D0D0D0D0D0, 0xD0D0D0D0D0D0D0D0) == 0x3BBD84CE539E68C4); | |
| assert(desEncryptTest(0xD1D1D1D1D1D1D1D1, 0xD1D1D1D1D1D1D1D1) == 0xCF3E4F3E026E2C8E); | |
| assert(desEncryptTest(0xD2D2D2D2D2D2D2D2, 0xD2D2D2D2D2D2D2D2) == 0x82F85885D542AF58); | |
| assert(desEncryptTest(0xD3D3D3D3D3D3D3D3, 0xD3D3D3D3D3D3D3D3) == 0x22D334D6493B3CB6); | |
| assert(desEncryptTest(0xD4D4D4D4D4D4D4D4, 0xD4D4D4D4D4D4D4D4) == 0x47E9CB3E3154D673); | |
| assert(desEncryptTest(0xD5D5D5D5D5D5D5D5, 0xD5D5D5D5D5D5D5D5) == 0x2352BCC708ADC7E9); | |
| assert(desEncryptTest(0xD6D6D6D6D6D6D6D6, 0xD6D6D6D6D6D6D6D6) == 0x8C0F3BA0C8601980); | |
| assert(desEncryptTest(0xD7D7D7D7D7D7D7D7, 0xD7D7D7D7D7D7D7D7) == 0xEE5E9FD70CEF00E9); | |
| assert(desEncryptTest(0xD8D8D8D8D8D8D8D8, 0xD8D8D8D8D8D8D8D8) == 0xDEF6BDA6CABF9547); | |
| assert(desEncryptTest(0xD9D9D9D9D9D9D9D9, 0xD9D9D9D9D9D9D9D9) == 0x4DADD04A0EA70F20); | |
| assert(desEncryptTest(0xDADADADADADADADA, 0xDADADADADADADADA) == 0xC1AA16689EE1B482); | |
| assert(desEncryptTest(0xDBDBDBDBDBDBDBDB, 0xDBDBDBDBDBDBDBDB) == 0xF45FC26193E69AEE); | |
| assert(desEncryptTest(0xDCDCDCDCDCDCDCDC, 0xDCDCDCDCDCDCDCDC) == 0xD0CFBB937CEDBFB5); | |
| assert(desEncryptTest(0xDDDDDDDDDDDDDDDD, 0xDDDDDDDDDDDDDDDD) == 0xF0752004EE23D87B); | |
| assert(desEncryptTest(0xDEDEDEDEDEDEDEDE, 0xDEDEDEDEDEDEDEDE) == 0x77A791E28AA464A5); | |
| assert(desEncryptTest(0xDFDFDFDFDFDFDFDF, 0xDFDFDFDFDFDFDFDF) == 0xE7562A7F56FF4966); | |
| assert(desEncryptTest(0xE0E0E0E0E0E0E0E0, 0xE0E0E0E0E0E0E0E0) == 0xB026913F2CCFB109); | |
| assert(desEncryptTest(0xE1E1E1E1E1E1E1E1, 0xE1E1E1E1E1E1E1E1) == 0x0DB572DDCE388AC7); | |
| assert(desEncryptTest(0xE2E2E2E2E2E2E2E2, 0xE2E2E2E2E2E2E2E2) == 0xD9FA6595F0C094CA); | |
| assert(desEncryptTest(0xE3E3E3E3E3E3E3E3, 0xE3E3E3E3E3E3E3E3) == 0xADE4804C4BE4486E); | |
| assert(desEncryptTest(0xE4E4E4E4E4E4E4E4, 0xE4E4E4E4E4E4E4E4) == 0x007B81F520E6D7DA); | |
| assert(desEncryptTest(0xE5E5E5E5E5E5E5E5, 0xE5E5E5E5E5E5E5E5) == 0x961AEB77BFC10B3C); | |
| assert(desEncryptTest(0xE6E6E6E6E6E6E6E6, 0xE6E6E6E6E6E6E6E6) == 0x8A8DD870C9B14AF2); | |
| assert(desEncryptTest(0xE7E7E7E7E7E7E7E7, 0xE7E7E7E7E7E7E7E7) == 0x3CC02E14B6349B25); | |
| assert(desEncryptTest(0xE8E8E8E8E8E8E8E8, 0xE8E8E8E8E8E8E8E8) == 0xBAD3EE68BDDB9607); | |
| assert(desEncryptTest(0xE9E9E9E9E9E9E9E9, 0xE9E9E9E9E9E9E9E9) == 0xDFF918E93BDAD292); | |
| assert(desEncryptTest(0xEAEAEAEAEAEAEAEA, 0xEAEAEAEAEAEAEAEA) == 0x8FE559C7CD6FA56D); | |
| assert(desEncryptTest(0xEBEBEBEBEBEBEBEB, 0xEBEBEBEBEBEBEBEB) == 0xC88480835C1A444C); | |
| assert(desEncryptTest(0xECECECECECECECEC, 0xECECECECECECECEC) == 0xD6EE30A16B2CC01E); | |
| assert(desEncryptTest(0xEDEDEDEDEDEDEDED, 0xEDEDEDEDEDEDEDED) == 0x6932D887B2EA9C1A); | |
| assert(desEncryptTest(0xEEEEEEEEEEEEEEEE, 0xEEEEEEEEEEEEEEEE) == 0x0BFC865461F13ACC); | |
| assert(desEncryptTest(0xEFEFEFEFEFEFEFEF, 0xEFEFEFEFEFEFEFEF) == 0x228AEA0D403E807A); | |
| assert(desEncryptTest(0xF0F0F0F0F0F0F0F0, 0xF0F0F0F0F0F0F0F0) == 0x2A2891F65BB8173C); | |
| assert(desEncryptTest(0xF1F1F1F1F1F1F1F1, 0xF1F1F1F1F1F1F1F1) == 0x5D1B8FAF7839494B); | |
| assert(desEncryptTest(0xF2F2F2F2F2F2F2F2, 0xF2F2F2F2F2F2F2F2) == 0x1C0A9280EECF5D48); | |
| assert(desEncryptTest(0xF3F3F3F3F3F3F3F3, 0xF3F3F3F3F3F3F3F3) == 0x6CBCE951BBC30F74); | |
| assert(desEncryptTest(0xF4F4F4F4F4F4F4F4, 0xF4F4F4F4F4F4F4F4) == 0x9CA66E96BD08BC70); | |
| assert(desEncryptTest(0xF5F5F5F5F5F5F5F5, 0xF5F5F5F5F5F5F5F5) == 0xF5D779FCFBB28BF3); | |
| assert(desEncryptTest(0xF6F6F6F6F6F6F6F6, 0xF6F6F6F6F6F6F6F6) == 0x0FEC6BBF9B859184); | |
| assert(desEncryptTest(0xF7F7F7F7F7F7F7F7, 0xF7F7F7F7F7F7F7F7) == 0xEF88D2BF052DBDA8); | |
| assert(desEncryptTest(0xF8F8F8F8F8F8F8F8, 0xF8F8F8F8F8F8F8F8) == 0x39ADBDDB7363090D); | |
| assert(desEncryptTest(0xF9F9F9F9F9F9F9F9, 0xF9F9F9F9F9F9F9F9) == 0xC0AEAF445F7E2A7A); | |
| assert(desEncryptTest(0xFAFAFAFAFAFAFAFA, 0xFAFAFAFAFAFAFAFA) == 0xC66F54067298D4E9); | |
| assert(desEncryptTest(0xFBFBFBFBFBFBFBFB, 0xFBFBFBFBFBFBFBFB) == 0xE0BA8F4488AAF97C); | |
| assert(desEncryptTest(0xFCFCFCFCFCFCFCFC, 0xFCFCFCFCFCFCFCFC) == 0x67B36E2875D9631C); | |
| assert(desEncryptTest(0xFDFDFDFDFDFDFDFD, 0xFDFDFDFDFDFDFDFD) == 0x1ED83D49E267191D); | |
| assert(desEncryptTest(0xFEFEFEFEFEFEFEFE, 0xFEFEFEFEFEFEFEFE) == 0x66B2B23EA84693AD); | |
| assert(desEncryptTest(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF) == 0x7359B2163E4EDC58); | |
| assert(desEncryptTest(0x0001020304050607, 0x0011223344556677) == 0x3EF0A891CF8ED990); | |
| assert(desEncryptTest(0x2BD6459F82C5B300, 0xEA024714AD5C4D84) == 0x126EFE8ED312190A); | |
| assert(desEncryptTest(0x8000000000000000, 0x1C29EEE68829F666) == 0x0000000000000000); | |
| assert(desEncryptTest(0x4000000000000000, 0x1EBAA7E2844108D1) == 0x0000000000000000); | |
| assert(desEncryptTest(0x2000000000000000, 0xDD75FF6DD1D07407) == 0x0000000000000000); | |
| assert(desEncryptTest(0x1000000000000000, 0x6C0D0366D7FC1E93) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0800000000000000, 0x65FB4EDB3731E927) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0400000000000000, 0x1A4795892BD82629) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0200000000000000, 0x6E228A9F47A31527) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0100000000000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0080000000000000, 0x5A01EA0528FE4DBC) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0040000000000000, 0x2AA7048B7F843ACC) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0020000000000000, 0xFB1426125A5AE00F) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0010000000000000, 0x3ACC2A83D9FE0CF8) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0008000000000000, 0x2616451A5426B97D) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0004000000000000, 0xB85395BAA402FFB9) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0002000000000000, 0xD02182A2E8E573A1) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0001000000000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000800000000000, 0xC6ED12A06A4CC156) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000400000000000, 0x64EEA4A26D381E26) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000200000000000, 0x4EA9D5AA0C2C3C4E) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000100000000000, 0x8D8661C34C6F4D21) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000080000000000, 0xE3FF48ACC26B8A33) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000040000000000, 0xC57374F43AF34F17) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000020000000000, 0x857FB4722F85F57F) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000010000000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000008000000000, 0xD86AFF1EE01AAA00) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000004000000000, 0x7B4937859794FC5E) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000002000000000, 0x05EF338303C238D9) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000001000000000, 0x0E2F05283A7DD2B2) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000800000000, 0x661502A71B53EAD4) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000400000000, 0x1EBBFCECD36FA671) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000200000000, 0x6800E59AF69486CD) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000100000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000080000000, 0x82453A94E658B38D) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000040000000, 0xBD0622EBC5E34C41) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000020000000, 0x4C3E34B8BE70C9F2) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000010000000, 0x1027E471BF185728) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000008000000, 0x39DE1CB6FE1959A4) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000004000000, 0xE3C3CC1A68B58E5D) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000002000000, 0xB60F05703D5012FA) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000001000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000800000, 0xD19667C59D94D4F7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000400000, 0x3CA5963292ED8725) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000200000, 0x1F2B2104BF62E510) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000100000, 0x322D5F2AD1F6C3F8) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000080000, 0x202D8D2E16C3DE65) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000040000, 0x10B71036AF979F7A) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000020000, 0x980048358ADB5189) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000010000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000008000, 0x737589DC3ADDB4D5) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000004000, 0xF7900FD046800D04) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000002000, 0x95BE3F4238740526) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000001000, 0x656F2445A164F9E1) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000800, 0x6C77909A14006365) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000400, 0xB3524D3045B44663) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000200, 0x4BFE8E87CFF074F7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000100, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000080, 0x0EBFE2B0D89F9EC3) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000040, 0xA34785BBA566D0D5) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000020, 0xF2B12EA4CF8F6FC2) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000010, 0x5D65F4BD79E2AD83) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000008, 0x6D2D1CC9A52139BD) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000004, 0x6CB9F25ABAAA9DDD) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000002, 0x2F3F20C13DEF464C) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000001, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x95F8A5E5DD31D900) == 0x8000000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xDD7F121CA5015619) == 0x4000000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x2E8653104F3834EA) == 0x2000000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x4BD388FF6CD81D4F) == 0x1000000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x20B9E767B2FB1456) == 0x0800000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x55579380D77138EF) == 0x0400000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x6CC5DEFAAF04512F) == 0x0200000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x0D9F279BA5D87260) == 0x0100000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xD9031B0271BD5A0A) == 0x0080000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x424250B37C3DD951) == 0x0040000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xB8061B7ECD9A21E5) == 0x0020000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xF15D0F286B65BD28) == 0x0010000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xADD0CC8D6E5DEBA1) == 0x0008000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE6D5F82752AD63D1) == 0x0004000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xECBFE3BD3F591A5E) == 0x0002000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xF356834379D165CD) == 0x0001000000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x2B9F982F20037FA9) == 0x0000800000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x889DE068A16F0BE6) == 0x0000400000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE19E275D846A1298) == 0x0000200000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x329A8ED523D71AEC) == 0x0000100000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE7FCE22557D23C97) == 0x0000080000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x12A9F5817FF2D65D) == 0x0000040000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xA484C3AD38DC9C19) == 0x0000020000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xFBE00A8A1EF8AD72) == 0x0000010000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x750D079407521363) == 0x0000008000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x64FEED9C724C2FAF) == 0x0000004000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xF02B263B328E2B60) == 0x0000002000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x9D64555A9A10B852) == 0x0000001000000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xD106FF0BED5255D7) == 0x0000000800000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE1652C6B138C64A5) == 0x0000000400000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE428581186EC8F46) == 0x0000000200000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xAEB5F5EDE22D1A36) == 0x0000000100000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xE943D7568AEC0C5C) == 0x0000000080000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xDF98C8276F54B04B) == 0x0000000040000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xB160E4680F6C696F) == 0x0000000020000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xFA0752B07D9C4AB8) == 0x0000000010000000); | |
| assert(desEncryptTest(0x0000000000000000, 0xCA3A2B036DBC8502) == 0x0000000008000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x5E0905517BB59BCF) == 0x0000000004000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x814EEB3B91D90726) == 0x0000000002000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x4D49DB1532919C9F) == 0x0000000001000000); | |
| assert(desEncryptTest(0x0000000000000000, 0x25EB5FC3F8CF0621) == 0x0000000000800000); | |
| assert(desEncryptTest(0x0000000000000000, 0xAB6A20C0620D1C6F) == 0x0000000000400000); | |
| assert(desEncryptTest(0x0000000000000000, 0x79E90DBC98F92CCA) == 0x0000000000200000); | |
| assert(desEncryptTest(0x0000000000000000, 0x866ECEDD8072BB0E) == 0x0000000000100000); | |
| assert(desEncryptTest(0x0000000000000000, 0x8B54536F2F3E64A8) == 0x0000000000080000); | |
| assert(desEncryptTest(0x0000000000000000, 0xEA51D3975595B86B) == 0x0000000000040000); | |
| assert(desEncryptTest(0x0000000000000000, 0xCAFFC6AC4542DE31) == 0x0000000000020000); | |
| assert(desEncryptTest(0x0000000000000000, 0x8DD45A2DDF90796C) == 0x0000000000010000); | |
| assert(desEncryptTest(0x0000000000000000, 0x1029D55E880EC2D0) == 0x0000000000008000); | |
| assert(desEncryptTest(0x0000000000000000, 0x5D86CB23639DBEA9) == 0x0000000000004000); | |
| assert(desEncryptTest(0x0000000000000000, 0x1D1CA853AE7C0C5F) == 0x0000000000002000); | |
| assert(desEncryptTest(0x0000000000000000, 0xCE332329248F3228) == 0x0000000000001000); | |
| assert(desEncryptTest(0x0000000000000000, 0x8405D1ABE24FB942) == 0x0000000000000800); | |
| assert(desEncryptTest(0x0000000000000000, 0xE643D78090CA4207) == 0x0000000000000400); | |
| assert(desEncryptTest(0x0000000000000000, 0x48221B9937748A23) == 0x0000000000000200); | |
| assert(desEncryptTest(0x0000000000000000, 0xDD7C0BBD61FAFD54) == 0x0000000000000100); | |
| assert(desEncryptTest(0x0000000000000000, 0x2FBC291A570DB5C4) == 0x0000000000000080); | |
| assert(desEncryptTest(0x0000000000000000, 0xE07C30D7E4E26E12) == 0x0000000000000040); | |
| assert(desEncryptTest(0x0000000000000000, 0x0953E2258E8E90A1) == 0x0000000000000020); | |
| assert(desEncryptTest(0x0000000000000000, 0x5B711BC4CEEBF2EE) == 0x0000000000000010); | |
| assert(desEncryptTest(0x0000000000000000, 0xCC083F1E6D9E85F6) == 0x0000000000000008); | |
| assert(desEncryptTest(0x0000000000000000, 0xD2FD8867D50D2DFE) == 0x0000000000000004); | |
| assert(desEncryptTest(0x0000000000000000, 0x06E7EA22CE92708F) == 0x0000000000000002); | |
| assert(desEncryptTest(0x0000000000000000, 0x166B40B44ABA4BD6) == 0x0000000000000001); | |
| assert(desEncryptTest(0x0000000000000000, 0x8CA64DE9C1B123A7) == 0x0000000000000000); | |
| assert(desEncryptTest(0x0101010101010101, 0x994D4DC157B96C52) == 0x0101010101010101); | |
| assert(desEncryptTest(0x0202020202020202, 0xF09FA63CCDFA2BAD) == 0x0202020202020202); | |
| assert(desEncryptTest(0x0303030303030303, 0x918C7AEFF893AD51) == 0x0303030303030303); | |
| assert(desEncryptTest(0x0404040404040404, 0x8991C0C48CF0AF81) == 0x0404040404040404); | |
| assert(desEncryptTest(0x0505050505050505, 0x25676954529031CB) == 0x0505050505050505); | |
| assert(desEncryptTest(0x0606060606060606, 0xAAEF9DD11DE74546) == 0x0606060606060606); | |
| assert(desEncryptTest(0x0707070707070707, 0x8DFFA9A0B2F2548B) == 0x0707070707070707); | |
| assert(desEncryptTest(0x0808080808080808, 0xD932847445DA4FD8) == 0x0808080808080808); | |
| assert(desEncryptTest(0x0909090909090909, 0x5110E59AAEC7335B) == 0x0909090909090909); | |
| assert(desEncryptTest(0x0A0A0A0A0A0A0A0A, 0xCE681111BA3B7B11) == 0x0A0A0A0A0A0A0A0A); | |
| assert(desEncryptTest(0x0B0B0B0B0B0B0B0B, 0xB5AD1C8C49965CCA) == 0x0B0B0B0B0B0B0B0B); | |
| assert(desEncryptTest(0x0C0C0C0C0C0C0C0C, 0x9F9958F3E2767EA7) == 0x0C0C0C0C0C0C0C0C); | |
| assert(desEncryptTest(0x0D0D0D0D0D0D0D0D, 0x149D6492A0D809EE) == 0x0D0D0D0D0D0D0D0D); | |
| assert(desEncryptTest(0x0E0E0E0E0E0E0E0E, 0xF1EDC5B1F98F6313) == 0x0E0E0E0E0E0E0E0E); | |
| assert(desEncryptTest(0x0F0F0F0F0F0F0F0F, 0x57057A2B85367BED) == 0x0F0F0F0F0F0F0F0F); | |
| assert(desEncryptTest(0x1010101010101010, 0xB376C874E6F987D0) == 0x1010101010101010); | |
| assert(desEncryptTest(0x1111111111111111, 0x237B2304C393D3AC) == 0x1111111111111111); | |
| assert(desEncryptTest(0x1212121212121212, 0xA2F68A96740E3F2D) == 0x1212121212121212); | |
| assert(desEncryptTest(0x1313131313131313, 0x1D779D8AB79E89EF) == 0x1313131313131313); | |
| assert(desEncryptTest(0x1414141414141414, 0x1E59064FFEA191EF) == 0x1414141414141414); | |
| assert(desEncryptTest(0x1515151515151515, 0x53B4DAE06761FFA1) == 0x1515151515151515); | |
| assert(desEncryptTest(0x1616161616161616, 0x550FB1A5507A49ED) == 0x1616161616161616); | |
| assert(desEncryptTest(0x1717171717171717, 0x64FFAFFBB608B002) == 0x1717171717171717); | |
| assert(desEncryptTest(0x1818181818181818, 0x2EF928E663986E1C) == 0x1818181818181818); | |
| assert(desEncryptTest(0x1919191919191919, 0x9C7EB95CB182233E) == 0x1919191919191919); | |
| assert(desEncryptTest(0x1A1A1A1A1A1A1A1A, 0xB62CFEB46DD18577) == 0x1A1A1A1A1A1A1A1A); | |
| assert(desEncryptTest(0x1B1B1B1B1B1B1B1B, 0x8F9F498CBA6DF908) == 0x1B1B1B1B1B1B1B1B); | |
| assert(desEncryptTest(0x1C1C1C1C1C1C1C1C, 0x3017633FB8197C95) == 0x1C1C1C1C1C1C1C1C); | |
| assert(desEncryptTest(0x1D1D1D1D1D1D1D1D, 0x079FA37ED80BA064) == 0x1D1D1D1D1D1D1D1D); | |
| assert(desEncryptTest(0x1E1E1E1E1E1E1E1E, 0xC8040684A207D1B5) == 0x1E1E1E1E1E1E1E1E); | |
| assert(desEncryptTest(0x1F1F1F1F1F1F1F1F, 0x61B145D97C491523) == 0x1F1F1F1F1F1F1F1F); | |
| assert(desEncryptTest(0x2020202020202020, 0x9073C79790306F7D) == 0x2020202020202020); | |
| assert(desEncryptTest(0x2121212121212121, 0xA80B2BFEBE10A4DA) == 0x2121212121212121); | |
| assert(desEncryptTest(0x2222222222222222, 0xD105F93010B3B6F5) == 0x2222222222222222); | |
| assert(desEncryptTest(0x2323232323232323, 0x8F521B75483A0B94) == 0x2323232323232323); | |
| assert(desEncryptTest(0x2424242424242424, 0xC8F028A3EE60B289) == 0x2424242424242424); | |
| assert(desEncryptTest(0x2525252525252525, 0xDC8D45D7517FB58C) == 0x2525252525252525); | |
| assert(desEncryptTest(0x2626262626262626, 0xA827E72CD184555E) == 0x2626262626262626); | |
| assert(desEncryptTest(0x2727272727272727, 0x11A586CDC15F4B62) == 0x2727272727272727); | |
| assert(desEncryptTest(0x2828282828282828, 0x6066EF85FF1F8A46) == 0x2828282828282828); | |
| assert(desEncryptTest(0x2929292929292929, 0x64F017F35A3F50D1) == 0x2929292929292929); | |
| assert(desEncryptTest(0x2A2A2A2A2A2A2A2A, 0x19D9B4C305AB5AC4) == 0x2A2A2A2A2A2A2A2A); | |
| assert(desEncryptTest(0x2B2B2B2B2B2B2B2B, 0xD13BE446B15397C0) == 0x2B2B2B2B2B2B2B2B); | |
| assert(desEncryptTest(0x2C2C2C2C2C2C2C2C, 0xA1AAAC9B6D3DAB0A) == 0x2C2C2C2C2C2C2C2C); | |
| assert(desEncryptTest(0x2D2D2D2D2D2D2D2D, 0x60EF54CED063EEAC) == 0x2D2D2D2D2D2D2D2D); | |
| assert(desEncryptTest(0x2E2E2E2E2E2E2E2E, 0x659EF16E9EFFC16D) == 0x2E2E2E2E2E2E2E2E); | |
| assert(desEncryptTest(0x2F2F2F2F2F2F2F2F, 0x7F991C35E71F8D95) == 0x2F2F2F2F2F2F2F2F); | |
| assert(desEncryptTest(0x3030303030303030, 0x335AC5E54AA4C5FA) == 0x3030303030303030); | |
| assert(desEncryptTest(0x3131313131313131, 0x6D0A7ECC98A019A6) == 0x3131313131313131); | |
| assert(desEncryptTest(0x3232323232323232, 0xDB71F2F904CE4467) == 0x3232323232323232); | |
| assert(desEncryptTest(0x3333333333333333, 0x19B6A607F49D7EBF) == 0x3333333333333333); | |
| assert(desEncryptTest(0x3434343434343434, 0x086DA2A46819B2EC) == 0x3434343434343434); | |
| assert(desEncryptTest(0x3535353535353535, 0xBFBEB4BB6C8BA8D3) == 0x3535353535353535); | |
| assert(desEncryptTest(0x3636363636363636, 0xC0EA975A16621073) == 0x3636363636363636); | |
| assert(desEncryptTest(0x3737373737373737, 0xB53D58A1CAD79864) == 0x3737373737373737); | |
| assert(desEncryptTest(0x3838383838383838, 0xB7F074CB09D21987) == 0x3838383838383838); | |
| assert(desEncryptTest(0x3939393939393939, 0xE6F6D6E5DCCAFBAF) == 0x3939393939393939); | |
| assert(desEncryptTest(0x3A3A3A3A3A3A3A3A, 0x428395367157DB18) == 0x3A3A3A3A3A3A3A3A); | |
| assert(desEncryptTest(0x3B3B3B3B3B3B3B3B, 0xB71F8389C32F928E) == 0x3B3B3B3B3B3B3B3B); | |
| assert(desEncryptTest(0x3C3C3C3C3C3C3C3C, 0x290DDC00BAFBF6C0) == 0x3C3C3C3C3C3C3C3C); | |
| assert(desEncryptTest(0x3D3D3D3D3D3D3D3D, 0x96F8EC19C7C00F69) == 0x3D3D3D3D3D3D3D3D); | |
| assert(desEncryptTest(0x3E3E3E3E3E3E3E3E, 0xE1E2B92BEC7B6EDA) == 0x3E3E3E3E3E3E3E3E); | |
| assert(desEncryptTest(0x3F3F3F3F3F3F3F3F, 0x4FCD12FF1A0F4828) == 0x3F3F3F3F3F3F3F3F); | |
| assert(desEncryptTest(0x4040404040404040, 0xFDA1AEAC4103BEC7) == 0x4040404040404040); | |
| assert(desEncryptTest(0x4141414141414141, 0xC023018BB50973DF) == 0x4141414141414141); | |
| assert(desEncryptTest(0x4242424242424242, 0x2F17AB3C4EF47CED) == 0x4242424242424242); | |
| assert(desEncryptTest(0x4343434343434343, 0x403E4F9726A43E2B) == 0x4343434343434343); | |
| assert(desEncryptTest(0x4444444444444444, 0x300FB94913B09D9F) == 0x4444444444444444); | |
| assert(desEncryptTest(0x4545454545454545, 0xCC3368EE3DD10A86) == 0x4545454545454545); | |
| assert(desEncryptTest(0x4646464646464646, 0x4047149B98541E84) == 0x4646464646464646); | |
| assert(desEncryptTest(0x4747474747474747, 0x6F50E18DA9045F21) == 0x4747474747474747); | |
| assert(desEncryptTest(0x4848484848484848, 0x8714D44CAC7D0D14) == 0x4848484848484848); | |
| assert(desEncryptTest(0x4949494949494949, 0x83829CFFC32CED9B) == 0x4949494949494949); | |
| assert(desEncryptTest(0x4A4A4A4A4A4A4A4A, 0x16044259F6FEEF2A) == 0x4A4A4A4A4A4A4A4A); | |
| assert(desEncryptTest(0x4B4B4B4B4B4B4B4B, 0xDAEB0CCC9F9C02A7) == 0x4B4B4B4B4B4B4B4B); | |
| assert(desEncryptTest(0x4C4C4C4C4C4C4C4C, 0x1F9442EA265CB749) == 0x4C4C4C4C4C4C4C4C); | |
| assert(desEncryptTest(0x4D4D4D4D4D4D4D4D, 0xE4911A6B657A86BE) == 0x4D4D4D4D4D4D4D4D); | |
| assert(desEncryptTest(0x4E4E4E4E4E4E4E4E, 0x67464D8D5A2822CF) == 0x4E4E4E4E4E4E4E4E); | |
| assert(desEncryptTest(0x4F4F4F4F4F4F4F4F, 0xC1419997381C7DA3) == 0x4F4F4F4F4F4F4F4F); | |
| assert(desEncryptTest(0x5050505050505050, 0x599A5CD62A06D027) == 0x5050505050505050); | |
| assert(desEncryptTest(0x5151515151515151, 0x88FD236C41B3BB51) == 0x5151515151515151); | |
| assert(desEncryptTest(0x5252525252525252, 0x41CC247560605B0B) == 0x5252525252525252); | |
| assert(desEncryptTest(0x5353535353535353, 0x0F91178929EF4AA1) == 0x5353535353535353); | |
| assert(desEncryptTest(0x5454545454545454, 0xDC644E7A6FAA6446) == 0x5454545454545454); | |
| assert(desEncryptTest(0x5555555555555555, 0x27BDEAC7848061C2) == 0x5555555555555555); | |
| assert(desEncryptTest(0x5656565656565656, 0x51115EC4EBDDE14E) == 0x5656565656565656); | |
| assert(desEncryptTest(0x5757575757575757, 0xA1731C55A4FB1B12) == 0x5757575757575757); | |
| assert(desEncryptTest(0x5858585858585858, 0x883D1CB568FA4AF6) == 0x5858585858585858); | |
| assert(desEncryptTest(0x5959595959595959, 0xEE21D431F34E89A5) == 0x5959595959595959); | |
| assert(desEncryptTest(0x5A5A5A5A5A5A5A5A, 0x8ED4FA5DF0B7BAA9) == 0x5A5A5A5A5A5A5A5A); | |
| assert(desEncryptTest(0x5B5B5B5B5B5B5B5B, 0x8AA3372D4A4CF54D) == 0x5B5B5B5B5B5B5B5B); | |
| assert(desEncryptTest(0x5C5C5C5C5C5C5C5C, 0x6E9D4FF9DE08AAD1) == 0x5C5C5C5C5C5C5C5C); | |
| assert(desEncryptTest(0x5D5D5D5D5D5D5D5D, 0x302DE41DFAE50C3E) == 0x5D5D5D5D5D5D5D5D); | |
| assert(desEncryptTest(0x5E5E5E5E5E5E5E5E, 0x15238624D6D73121) == 0x5E5E5E5E5E5E5E5E); | |
| assert(desEncryptTest(0x5F5F5F5F5F5F5F5F, 0x960ADA6F022E3019) == 0x5F5F5F5F5F5F5F5F); | |
| assert(desEncryptTest(0x6060606060606060, 0xCAF3211A707960D6) == 0x6060606060606060); | |
| assert(desEncryptTest(0x6161616161616161, 0xF7E458FA7081BE7D) == 0x6161616161616161); | |
| assert(desEncryptTest(0x6262626262626262, 0x5FAB0E843C6E5BA9) == 0x6262626262626262); | |
| assert(desEncryptTest(0x6363636363636363, 0x7CF40025EB32B66F) == 0x6363636363636363); | |
| assert(desEncryptTest(0x6464646464646464, 0x1D3FF19CA208D2B2) == 0x6464646464646464); | |
| assert(desEncryptTest(0x6565656565656565, 0xBDFBCA399EB932A0) == 0x6565656565656565); | |
| assert(desEncryptTest(0x6666666666666666, 0x29CE12AFEA960B70) == 0x6666666666666666); | |
| assert(desEncryptTest(0x6767676767676767, 0x82F8FB5140014B85) == 0x6767676767676767); | |
| assert(desEncryptTest(0x6868686868686868, 0x7B3C0F4E34F9D1E9) == 0x6868686868686868); | |
| assert(desEncryptTest(0x6969696969696969, 0x8F7B0EAD94E39A13) == 0x6969696969696969); | |
| assert(desEncryptTest(0x6A6A6A6A6A6A6A6A, 0x6D3F31C7778EAD8A) == 0x6A6A6A6A6A6A6A6A); | |
| assert(desEncryptTest(0x6B6B6B6B6B6B6B6B, 0x37B18B3906BAB3A8) == 0x6B6B6B6B6B6B6B6B); | |
| assert(desEncryptTest(0x6C6C6C6C6C6C6C6C, 0x12B4CB7A4CBE767B) == 0x6C6C6C6C6C6C6C6C); | |
| assert(desEncryptTest(0x6D6D6D6D6D6D6D6D, 0x2420B66A1055C0E9) == 0x6D6D6D6D6D6D6D6D); | |
| assert(desEncryptTest(0x6E6E6E6E6E6E6E6E, 0x7E8E816788C6D588) == 0x6E6E6E6E6E6E6E6E); | |
| assert(desEncryptTest(0x6F6F6F6F6F6F6F6F, 0xC24105E33E184FF6) == 0x6F6F6F6F6F6F6F6F); | |
| assert(desEncryptTest(0x7070707070707070, 0xE4A18C1C24EBFBB9) == 0x7070707070707070); | |
| assert(desEncryptTest(0x7171717171717171, 0x89BDBD3DE031EED6) == 0x7171717171717171); | |
| assert(desEncryptTest(0x7272727272727272, 0xDBB840AF153D42DC) == 0x7272727272727272); | |
| assert(desEncryptTest(0x7373737373737373, 0x5198BB48B85D9073) == 0x7373737373737373); | |
| assert(desEncryptTest(0x7474747474747474, 0xEF91577024209D96) == 0x7474747474747474); | |
| assert(desEncryptTest(0x7575757575757575, 0x862D09602D08F4AF) == 0x7575757575757575); | |
| assert(desEncryptTest(0x7676767676767676, 0xDF8FDD3DA8BE381C) == 0x7676767676767676); | |
| assert(desEncryptTest(0x7777777777777777, 0xF4FA92CAF1EA65C8) == 0x7777777777777777); | |
| assert(desEncryptTest(0x7878787878787878, 0x6C51D39A736AB06E) == 0x7878787878787878); | |
| assert(desEncryptTest(0x7979797979797979, 0xCA78FA0F8940CDB6) == 0x7979797979797979); | |
| assert(desEncryptTest(0x7A7A7A7A7A7A7A7A, 0xE32531D4F4783A94) == 0x7A7A7A7A7A7A7A7A); | |
| assert(desEncryptTest(0x7B7B7B7B7B7B7B7B, 0xC983F15CAE1DEB86) == 0x7B7B7B7B7B7B7B7B); | |
| assert(desEncryptTest(0x7C7C7C7C7C7C7C7C, 0xF8895BF6515436F3) == 0x7C7C7C7C7C7C7C7C); | |
| assert(desEncryptTest(0x7D7D7D7D7D7D7D7D, 0x0B679E5008B5B69B) == 0x7D7D7D7D7D7D7D7D); | |
| assert(desEncryptTest(0x7E7E7E7E7E7E7E7E, 0x909D89361F819432) == 0x7E7E7E7E7E7E7E7E); | |
| assert(desEncryptTest(0x7F7F7F7F7F7F7F7F, 0xC8FCD27001B95D10) == 0x7F7F7F7F7F7F7F7F); | |
| assert(desEncryptTest(0x8080808080808080, 0x37032D8FFE46A2EF) == 0x8080808080808080); | |
| assert(desEncryptTest(0x8181818181818181, 0x6F6276C9E07E6BCD) == 0x8181818181818181); | |
| assert(desEncryptTest(0x8282828282828282, 0xF49861AFF74A4964) == 0x8282828282828282); | |
| assert(desEncryptTest(0x8383838383838383, 0x0776A409AEABC90C) == 0x8383838383838383); | |
| assert(desEncryptTest(0x8484848484848484, 0x367C0EA351E21479) == 0x8484848484848484); | |
| assert(desEncryptTest(0x8585858585858585, 0x1CDACE2B0B87C56B) == 0x8585858585858585); | |
| assert(desEncryptTest(0x8686868686868686, 0x358705F076BF3249) == 0x8686868686868686); | |
| assert(desEncryptTest(0x8787878787878787, 0x93AE2C658C954F91) == 0x8787878787878787); | |
| assert(desEncryptTest(0x8888888888888888, 0x0B056D350E159A37) == 0x8888888888888888); | |
| assert(desEncryptTest(0x8989898989898989, 0x207022C25741C7E3) == 0x8989898989898989); | |
| assert(desEncryptTest(0x8A8A8A8A8A8A8A8A, 0x79D2F69FD2F70B50) == 0x8A8A8A8A8A8A8A8A); | |
| assert(desEncryptTest(0x8B8B8B8B8B8B8B8B, 0x106EA88FDBDF6269) == 0x8B8B8B8B8B8B8B8B); | |
| assert(desEncryptTest(0x8C8C8C8C8C8C8C8C, 0xAE6744B747A26F8C) == 0x8C8C8C8C8C8C8C8C); | |
| assert(desEncryptTest(0x8D8D8D8D8D8D8D8D, 0x2447BF50EAC2BD23) == 0x8D8D8D8D8D8D8D8D); | |
| assert(desEncryptTest(0x8E8E8E8E8E8E8E8E, 0x764242C21FCE1129) == 0x8E8E8E8E8E8E8E8E); | |
| assert(desEncryptTest(0x8F8F8F8F8F8F8F8F, 0x1B5E73E3DB140446) == 0x8F8F8F8F8F8F8F8F); | |
| assert(desEncryptTest(0x9090909090909090, 0x3DBEFA1CC1E7B009) == 0x9090909090909090); | |
| assert(desEncryptTest(0x9191919191919191, 0x81717E9877392A77) == 0x9191919191919191); | |
| assert(desEncryptTest(0x9292929292929292, 0xDBDF4995EFAA3F16) == 0x9292929292929292); | |
| assert(desEncryptTest(0x9393939393939393, 0xED4B3485B3418984) == 0x9393939393939393); | |
| assert(desEncryptTest(0x9494949494949494, 0xC84E74C6F9454C57) == 0x9494949494949494); | |
| assert(desEncryptTest(0x9595959595959595, 0x92C0CE3888715275) == 0x9595959595959595); | |
| assert(desEncryptTest(0x9696969696969696, 0x7084F1526B1C65EC) == 0x9696969696969696); | |
| assert(desEncryptTest(0x9797979797979797, 0x84C3F0B1CB062E16) == 0x9797979797979797); | |
| assert(desEncryptTest(0x9898989898989898, 0x7D0704AEBFFEB47A) == 0x9898989898989898); | |
| assert(desEncryptTest(0x9999999999999999, 0xD631ED501569F48F) == 0x9999999999999999); | |
| assert(desEncryptTest(0x9A9A9A9A9A9A9A9A, 0x420435C66146CD5F) == 0x9A9A9A9A9A9A9A9A); | |
| assert(desEncryptTest(0x9B9B9B9B9B9B9B9B, 0xE2C00E635DF72D4D) == 0x9B9B9B9B9B9B9B9B); | |
| assert(desEncryptTest(0x9C9C9C9C9C9C9C9C, 0x830BFFDA14CD4990) == 0x9C9C9C9C9C9C9C9C); | |
| assert(desEncryptTest(0x9D9D9D9D9D9D9D9D, 0xA054F17BC391A456) == 0x9D9D9D9D9D9D9D9D); | |
| assert(desEncryptTest(0x9E9E9E9E9E9E9E9E, 0x081BA7058F7E4182) == 0x9E9E9E9E9E9E9E9E); | |
| assert(desEncryptTest(0x9F9F9F9F9F9F9F9F, 0x350CDEE58F869F29) == 0x9F9F9F9F9F9F9F9F); | |
| assert(desEncryptTest(0xA0A0A0A0A0A0A0A0, 0x69F52590FDD1CFE6) == 0xA0A0A0A0A0A0A0A0); | |
| assert(desEncryptTest(0xA1A1A1A1A1A1A1A1, 0xEADC79DB2928CEDE) == 0xA1A1A1A1A1A1A1A1); | |
| assert(desEncryptTest(0xA2A2A2A2A2A2A2A2, 0xCFD21BE2051AF3C1) == 0xA2A2A2A2A2A2A2A2); | |
| assert(desEncryptTest(0xA3A3A3A3A3A3A3A3, 0x9162B00621F7552E) == 0xA3A3A3A3A3A3A3A3); | |
| assert(desEncryptTest(0xA4A4A4A4A4A4A4A4, 0x755CC8D2B5B30AB2) == 0xA4A4A4A4A4A4A4A4); | |
| assert(desEncryptTest(0xA5A5A5A5A5A5A5A5, 0x712B05A20F484556) == 0xA5A5A5A5A5A5A5A5); | |
| assert(desEncryptTest(0xA6A6A6A6A6A6A6A6, 0x11DE2BCE0CB1765A) == 0xA6A6A6A6A6A6A6A6); | |
| assert(desEncryptTest(0xA7A7A7A7A7A7A7A7, 0x77C2E34A9705B509) == 0xA7A7A7A7A7A7A7A7); | |
| assert(desEncryptTest(0xA8A8A8A8A8A8A8A8, 0x5E8CE3AA5B04E4ED) == 0xA8A8A8A8A8A8A8A8); | |
| assert(desEncryptTest(0xA9A9A9A9A9A9A9A9, 0xAEEEA13B14221EB1) == 0xA9A9A9A9A9A9A9A9); | |
| assert(desEncryptTest(0xAAAAAAAAAAAAAAAA, 0xD84215387B7F9E3D) == 0xAAAAAAAAAAAAAAAA); | |
| assert(desEncryptTest(0xABABABABABABABAB, 0x239BB18590559BB9) == 0xABABABABABABABAB); | |
| assert(desEncryptTest(0xACACACACACACACAC, 0xF06EE876D610B55E) == 0xACACACACACACACAC); | |
| assert(desEncryptTest(0xADADADADADADADAD, 0xBE33DB8A9F9FA4F4) == 0xADADADADADADADAD); | |
| assert(desEncryptTest(0xAEAEAEAEAEAEAEAE, 0x7702DC93BE4C44AE) == 0xAEAEAEAEAEAEAEAE); | |
| assert(desEncryptTest(0xAFAFAFAFAFAFAFAF, 0xA665A329D5F92FD8) == 0xAFAFAFAFAFAFAFAF); | |
| assert(desEncryptTest(0xB0B0B0B0B0B0B0B0, 0x3EBE6668C7E3825C) == 0xB0B0B0B0B0B0B0B0); | |
| assert(desEncryptTest(0xB1B1B1B1B1B1B1B1, 0x98B9B272A5D7DD30) == 0xB1B1B1B1B1B1B1B1); | |
| assert(desEncryptTest(0xB2B2B2B2B2B2B2B2, 0x1B6EE5949A857941) == 0xB2B2B2B2B2B2B2B2); | |
| assert(desEncryptTest(0xB3B3B3B3B3B3B3B3, 0xE06BBD15D9A348B6) == 0xB3B3B3B3B3B3B3B3); | |
| assert(desEncryptTest(0xB4B4B4B4B4B4B4B4, 0x2514F3336063FD58) == 0xB4B4B4B4B4B4B4B4); | |
| assert(desEncryptTest(0xB5B5B5B5B5B5B5B5, 0xE9FBBDA6090110D5) == 0xB5B5B5B5B5B5B5B5); | |
| assert(desEncryptTest(0xB6B6B6B6B6B6B6B6, 0x7C7D63003CD31264) == 0xB6B6B6B6B6B6B6B6); | |
| assert(desEncryptTest(0xB7B7B7B7B7B7B7B7, 0x78EB2BB35382F2EB) == 0xB7B7B7B7B7B7B7B7); | |
| assert(desEncryptTest(0xB8B8B8B8B8B8B8B8, 0x90AF1E7256FBA0DE) == 0xB8B8B8B8B8B8B8B8); | |
| assert(desEncryptTest(0xB9B9B9B9B9B9B9B9, 0xBFB8EB6467ABE17B) == 0xB9B9B9B9B9B9B9B9); | |
| assert(desEncryptTest(0xBABABABABABABABA, 0x33CC9711C22EF579) == 0xBABABABABABABABA); | |
| assert(desEncryptTest(0xBBBBBBBBBBBBBBBB, 0xCFF046B6EC4F6260) == 0xBBBBBBBBBBBBBBBB); | |
| assert(desEncryptTest(0xBCBCBCBCBCBCBCBC, 0xBFC1B068D95BC1D4) == 0xBCBCBCBCBCBCBCBC); | |
| assert(desEncryptTest(0xBDBDBDBDBDBDBDBD, 0xD0E854C3B10B8312) == 0xBDBDBDBDBDBDBDBD); | |
| assert(desEncryptTest(0xBEBEBEBEBEBEBEBE, 0x3FDCFE744AF68C20) == 0xBEBEBEBEBEBEBEBE); | |
| assert(desEncryptTest(0xBFBFBFBFBFBFBFBF, 0x025E5153BEFC4138) == 0xBFBFBFBFBFBFBFBF); | |
| assert(desEncryptTest(0xC0C0C0C0C0C0C0C0, 0xB032ED00E5F0B7D7) == 0xC0C0C0C0C0C0C0C0); | |
| assert(desEncryptTest(0xC1C1C1C1C1C1C1C1, 0x1E1D46D413849125) == 0xC1C1C1C1C1C1C1C1); | |
| assert(desEncryptTest(0xC2C2C2C2C2C2C2C2, 0x690713E6383FF096) == 0xC2C2C2C2C2C2C2C2); | |
| assert(desEncryptTest(0xC3C3C3C3C3C3C3C3, 0xD6F223FF4504093F) == 0xC3C3C3C3C3C3C3C3); | |
| assert(desEncryptTest(0xC4C4C4C4C4C4C4C4, 0x48E07C763CD06D71) == 0xC4C4C4C4C4C4C4C4); | |
| assert(desEncryptTest(0xC5C5C5C5C5C5C5C5, 0xBD7C6AC98EA824E7) == 0xC5C5C5C5C5C5C5C5); | |
| assert(desEncryptTest(0xC6C6C6C6C6C6C6C6, 0x1909291A23350450) == 0xC6C6C6C6C6C6C6C6); | |
| assert(desEncryptTest(0xC7C7C7C7C7C7C7C7, 0x480F8B34F62DE678) == 0xC7C7C7C7C7C7C7C7); | |
| assert(desEncryptTest(0xC8C8C8C8C8C8C8C8, 0x4AC2A75E3528679B) == 0xC8C8C8C8C8C8C8C8); | |
| assert(desEncryptTest(0xC9C9C9C9C9C9C9C9, 0x3F1568A5E99DEF8C) == 0xC9C9C9C9C9C9C9C9); | |
| assert(desEncryptTest(0xCACACACACACACACA, 0x40414B449374572C) == 0xCACACACACACACACA); | |
| assert(desEncryptTest(0xCBCBCBCBCBCBCBCB, 0xF7925D5B97E64D13) == 0xCBCBCBCBCBCBCBCB); | |
| assert(desEncryptTest(0xCCCCCCCCCCCCCCCC, 0xE64959F80B628140) == 0xCCCCCCCCCCCCCCCC); | |
| assert(desEncryptTest(0xCDCDCDCDCDCDCDCD, 0x248E0D06FB31BB98) == 0xCDCDCDCDCDCDCDCD); | |
| assert(desEncryptTest(0xCECECECECECECECE, 0x92F58133675FE659) == 0xCECECECECECECECE); | |
| assert(desEncryptTest(0xCFCFCFCFCFCFCFCF, 0xCCA53A1AB55B3A05) == 0xCFCFCFCFCFCFCFCF); | |
| assert(desEncryptTest(0xD0D0D0D0D0D0D0D0, 0x8066E3CA18E0726A) == 0xD0D0D0D0D0D0D0D0); | |
| assert(desEncryptTest(0xD1D1D1D1D1D1D1D1, 0x9A610E9161003E92) == 0xD1D1D1D1D1D1D1D1); | |
| assert(desEncryptTest(0xD2D2D2D2D2D2D2D2, 0x9F10AB312F9C1153) == 0xD2D2D2D2D2D2D2D2); | |
| assert(desEncryptTest(0xD3D3D3D3D3D3D3D3, 0x5E55536492C254F5) == 0xD3D3D3D3D3D3D3D3); | |
| assert(desEncryptTest(0xD4D4D4D4D4D4D4D4, 0x2EC41BB94EAC683F) == 0xD4D4D4D4D4D4D4D4); | |
| assert(desEncryptTest(0xD5D5D5D5D5D5D5D5, 0xE6264B3CFA54A53B) == 0xD5D5D5D5D5D5D5D5); | |
| assert(desEncryptTest(0xD6D6D6D6D6D6D6D6, 0x9B0FE80CA5C0AF2E) == 0xD6D6D6D6D6D6D6D6); | |
| assert(desEncryptTest(0xD7D7D7D7D7D7D7D7, 0x9F99107A00E075B9) == 0xD7D7D7D7D7D7D7D7); | |
| assert(desEncryptTest(0xD8D8D8D8D8D8D8D8, 0xEE5A79323EA0B49D) == 0xD8D8D8D8D8D8D8D8); | |
| assert(desEncryptTest(0xD9D9D9D9D9D9D9D9, 0x57D818D32E7BAAA1) == 0xD9D9D9D9D9D9D9D9); | |
| assert(desEncryptTest(0xDADADADADADADADA, 0x2372BA28AE804A73) == 0xDADADADADADADADA); | |
| assert(desEncryptTest(0xDBDBDBDBDBDBDBDB, 0x370FD75C119F4D76) == 0xDBDBDBDBDBDBDBDB); | |
| assert(desEncryptTest(0xDCDCDCDCDCDCDCDC, 0x70ADE48AB7C5F46B) == 0xDCDCDCDCDCDCDCDC); | |
| assert(desEncryptTest(0xDDDDDDDDDDDDDDDD, 0x2EFA06CFEF4C490A) == 0xDDDDDDDDDDDDDDDD); | |
| assert(desEncryptTest(0xDEDEDEDEDEDEDEDE, 0x57F4D40141EF5B25) == 0xDEDEDEDEDEDEDEDE); | |
| assert(desEncryptTest(0xDFDFDFDFDFDFDFDF, 0x6F8C38686FCF9082) == 0xDFDFDFDFDFDFDFDF); | |
| assert(desEncryptTest(0xE0E0E0E0E0E0E0E0, 0x9E4EBA2683B6EADC) == 0xE0E0E0E0E0E0E0E0); | |
| assert(desEncryptTest(0xE1E1E1E1E1E1E1E1, 0x37FBF97B5DF82E4A) == 0xE1E1E1E1E1E1E1E1); | |
| assert(desEncryptTest(0xE2E2E2E2E2E2E2E2, 0xF8605C8127F45F9B) == 0xE2E2E2E2E2E2E2E2); | |
| assert(desEncryptTest(0xE3E3E3E3E3E3E3E3, 0xCFE89CC047E6836A) == 0xE3E3E3E3E3E3E3E3); | |
| assert(desEncryptTest(0xE4E4E4E4E4E4E4E4, 0x7060B673459206F7) == 0xE4E4E4E4E4E4E4E4); | |
| assert(desEncryptTest(0xE5E5E5E5E5E5E5E5, 0x49D3014B922E7A88) == 0xE5E5E5E5E5E5E5E5); | |
| assert(desEncryptTest(0xE6E6E6E6E6E6E6E6, 0x638146A34E7DDCC1) == 0xE6E6E6E6E6E6E6E6); | |
| assert(desEncryptTest(0xE7E7E7E7E7E7E7E7, 0xD106D7199C6791E3) == 0xE7E7E7E7E7E7E7E7); | |
| assert(desEncryptTest(0xE8E8E8E8E8E8E8E8, 0x9B00500449F74FFD) == 0xE8E8E8E8E8E8E8E8); | |
| assert(desEncryptTest(0xE9E9E9E9E9E9E9E9, 0xAAF04E5AAF85B612) == 0xE9E9E9E9E9E9E9E9); | |
| assert(desEncryptTest(0xEAEAEAEAEAEAEAEA, 0xAC4B251F989E005E) == 0xEAEAEAEAEAEAEAEA); | |
| assert(desEncryptTest(0xEBEBEBEBEBEBEBEB, 0xE1A6F9B0015E6E10) == 0xEBEBEBEBEBEBEBEB); | |
| assert(desEncryptTest(0xECECECECECECECEC, 0xE288627548617610) == 0xECECECECECECECEC); | |
| assert(desEncryptTest(0xEDEDEDEDEDEDEDED, 0x5D0975698BF1C0D2) == 0xEDEDEDEDEDEDEDED); | |
| assert(desEncryptTest(0xEEEEEEEEEEEEEEEE, 0xDC84DCFB3C6C2C53) == 0xEEEEEEEEEEEEEEEE); | |
| assert(desEncryptTest(0xEFEFEFEFEFEFEFEF, 0x4C89378B1906782F) == 0xEFEFEFEFEFEFEFEF); | |
| assert(desEncryptTest(0xF0F0F0F0F0F0F0F0, 0xA8FA85D47AC98412) == 0xF0F0F0F0F0F0F0F0); | |
| assert(desEncryptTest(0xF1F1F1F1F1F1F1F1, 0x0E123A4E06709CEC) == 0xF1F1F1F1F1F1F1F1); | |
| assert(desEncryptTest(0xF2F2F2F2F2F2F2F2, 0xEB629B6D5F27F611) == 0xF2F2F2F2F2F2F2F2); | |
| assert(desEncryptTest(0xF3F3F3F3F3F3F3F3, 0x6066A70C1D898158) == 0xF3F3F3F3F3F3F3F3); | |
| assert(desEncryptTest(0xF4F4F4F4F4F4F4F4, 0x4A52E373B669A335) == 0xF4F4F4F4F4F4F4F4); | |
| assert(desEncryptTest(0xF5F5F5F5F5F5F5F5, 0x3197EEEE45C484EE) == 0xF5F5F5F5F5F5F5F5); | |
| assert(desEncryptTest(0xF6F6F6F6F6F6F6F6, 0xAEEF1A655138CCA4) == 0xF6F6F6F6F6F6F6F6); | |
| assert(desEncryptTest(0xF7F7F7F7F7F7F7F7, 0x26CD7B8BBA25B027) == 0xF7F7F7F7F7F7F7F7); | |
| assert(desEncryptTest(0xF8F8F8F8F8F8F8F8, 0x7200565F4D0DAB74) == 0xF8F8F8F8F8F8F8F8); | |
| assert(desEncryptTest(0xF9F9F9F9F9F9F9F9, 0x5510622EE218BAB9) == 0xF9F9F9F9F9F9F9F9); | |
| assert(desEncryptTest(0xFAFAFAFAFAFAFAFA, 0xDA9896ABAD6FCE34) == 0xFAFAFAFAFAFAFAFA); | |
| assert(desEncryptTest(0xFBFBFBFBFBFBFBFB, 0x766E3F3B730F507E) == 0xFBFBFBFBFBFBFBFB); | |
| assert(desEncryptTest(0xFCFCFCFCFCFCFCFC, 0x6E738510076C52AE) == 0xFCFCFCFCFCFCFCFC); | |
| assert(desEncryptTest(0xFDFDFDFDFDFDFDFD, 0x0F6059C33205D452) == 0xFDFDFDFDFDFDFDFD); | |
| assert(desEncryptTest(0xFEFEFEFEFEFEFEFE, 0x66B2B23EA84693AD) == 0xFEFEFEFEFEFEFEFE); | |
| assert(desEncryptTest(0xFFFFFFFFFFFFFFFF, 0x7359B2163E4EDC58) == 0xFFFFFFFFFFFFFFFF); | |
| assert(desEncryptTest(0x0001020304050607, 0x41AD068548809D02) == 0x0011223344556677); | |
| assert(desEncryptTest(0x2BD6459F82C5B300, 0xB10F843097A0F932) == 0xEA024714AD5C4D84); | |
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Steps to reproduce: | |
| 1. cat /dev/urandom | head -c3000000 > random_test_data_small.bin | |
| 2. encrypt with OpenSSL: time openssl enc -des-ecb -in random_test_data_small.bin -out enc_small.bin -K 133457799BBCDFF1A -nopad -nosalt | |
| 3. build and run debug: zig test des.zig && zig build-exe des.zig && time ./des | |
| 4. check results with shasum: shasum enc_small.bin enc_zig_small.bin (SHOULD MATCH) | |
| 5. build release-fast and run: zig build-exe --release-fast des.zig && ./des | |
| 6. check results with shasum: shasum enc_small.bin enc_zig_small.bin (SHOULD NOT MATCH) | |
| 7. Uncomment line 192 in the code and repeat step 5 and 6 (should match this time!) | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment