From dbd8588585bf74deeb21f5740bcabab0c4a466c0 Mon Sep 17 00:00:00 2001 From: jbb01 <32650546+jbb01@users.noreply.github.com> Date: Wed, 10 Sep 2025 16:57:49 +0200 Subject: [PATCH] initial 7 --- src/bin/07_weird_assembly_machine.rs | 1216 +++++++++++++++++++++++++- 1 file changed, 1215 insertions(+), 1 deletion(-) diff --git a/src/bin/07_weird_assembly_machine.rs b/src/bin/07_weird_assembly_machine.rs index 82cd4c9..740fe02 100644 --- a/src/bin/07_weird_assembly_machine.rs +++ b/src/bin/07_weird_assembly_machine.rs @@ -1 +1,1215 @@ -// https://button.qedaka.de/07_weird_assembly_machine.html?name=Jonah&n=10000000000000070&x=4410539207075887818 \ No newline at end of file +// https://button.qedaka.de/07_weird_assembly_machine.html?name=Jonah&n=10000000000000070&x=4410539207075887818 + +const DATA: &[u8] = b"j\xe9~\x9c\xf5@\x16[\xac|\xf0O\x9e\xf0\x18,\x80Y\xf23`\xdd8\xceS\x9e>\xb6\x15o\xc7 \x22\x97\x8dRF\xc6\x9e+Q\xf4`\xb1\xdf\x82\x9d\xc3p\x86\x1fQ\x17~\xb5_\xa4\x88\x87\xa8\xffK\xec=\xd8\x13\xa8Z\x9a\x8e\xe7\x5c\x06\xefz\xd3\xff\xcc\xe98@L\x12\x03\xc5\xea\xcd\xea#\xe3q$R\xe3\xdbh7Tg\x99\x95\x94z$F\xab)\x94\x016M\x89+]\x8e^\x1a\x04v\x04\xe8e\xf4\xcb\x17\xc5\xeb\x93SS\x81\xe8\xfe\xabT\x1c\x97\xbc`\xe2\xb2Z\xd1\x8d\xa6\xc2!\xfa k:\xe9\x85\xf3\xe7\x1b(\x80X\x8bL\x88<\xa6\xaa\xbb\x87W;=WN<%\xdfh\xcdg\xda5\xfcs\xd7\x8f\x8a\x1e\xe2\xadl\xf2\x919Q\xc6\xddE\x0d\xd0{\x96\xc1\xf0\x89\xdc\xe38\xd9\x97\xc0\x81D\x8483Q\xa9\xc7\x9c*G\x8b\x04o\xb8\xe34K\xcd\xec(\x83\x89#S\xce\xda\xbb\xbcn\x9b\xbbl\x1eh\xf3@\xd7yp^\xfc\x81\xfbh\x17x\xbb\xaa\xf8x?\x95@I\x86\xa6T\x9c\x15qDP\xe4\x1a.\xbb\x88\xd1\xc2p\xd9C?\xca{\x17\x1f\x1f\xe2,\xa6\x0fK\xc4\x977EH5#\xa4:\xd9\xe5\x0c\xc8/c\x91h\xac\x13\x90\x5c;B\xb6\x8f\x18\xf9\xc0\x84g\xd9\xd4\xd6\x83\xa1\xe9\x98\xf8\xf8\xa9\xaf2\x16\xf14\xf0\xb4Z\x22#+\xfa\x17\xd0i\x82\xb3\xdf:\x97\x07\xb2qq\x8b\xb9D\xf8^\xcb\x05\x18\x05\xc9t@h\x8ap\xd4\x09\xb5\xec\x09\x10}\xfc\x1e\xe3?*\x0e>I\x10\x22\x86\xd8\x89\x95\x9f$}\xd2\xb4f\xf5\xabF\x90Bu\xfc\xc6!\xac\x89\xea\xf8\xc7(Q\xa6\x80\xcfqXs1\xabL\xca\xea\x0c\x0c\xcd\xc2g\xfd\xfbMc\x9e%\xed\xac7\xcb+\x11>E\x89\xcf\xbf\xcbc\xf9\xac6\x8f\x87\xce\x1bwT\xbfv_;\x14\x8dL\xc2\xae\x10E\xf6\x83T\x0cn\x83\xd7\x92\xaa\xce\xc9\x07\xc8\x8e\x5c_\xca\x9a\x8d\xae\xe5P\xc8\xc58\xa0,\xddVSZ]\xc1KK\xad;\xfe\xf5\xcf&\xba\xbc\x99\x02\xd5f\xe0\x07\xac\xad\xe6\xca\xb5\xeb\x0d\xf3;xsD\x9a\xbb\xe6\xa6B\xe91\xe7\xdd\x12\x9c\x9eL\x0d\x8e\x96\xc3*0=I\xf43\xbf4\x1c\xcb\xff\xdd\x15\x88\xb8pj\x97\x15\xa2\xf8Xl\x8b\x05\x9a\xfc\xad\xcc\x93(\xc6\x7fq\xdb\xfe\x16\x13\xd3\x8ac\x16F/\x09\x0d'\xd9\xd9\xf0\x86l:\x9e\x1f\xf2\xef\x92\x06\xb5\xe8\x92\xc7a\xa2\xc4\x5c\xe3:\x0f\xf1<\xd6E\x0aw \x8e\xfa[S\xaa\xa2\x125\x1a\xa8\x1f\xbc\x93\x0fJ\xb0\x96n\xba\x85\x9e\xba\x8b\xe6K\x1c2]JGT\xcb\xec\x0a\x03>\x1d%\x06\x18d^d\x8bY\xa0\xa2b\xf5\xa8\xc8\xf1[\xed<\xb6\xc5\xc0D\xf1*d,j{\x17OVk\x00h\x90a\xa7p\xf7\xb0!Ns\xc9\x10\x8c\xc7\xe3\xae\x1f1\x0fw\xa5u\x16\x94\xcaK\x088\x80\x989\x0e|4mE%w~B\xa6\xdd\x81\xdd\x9b\xb9E\xe1P\xceJ\x8dF\x9bP\x94\xb2}\xc2\xfc\xec\xe3\xc8\xf4N\xac\xfe%a\x91\xe4~|\xe5K\xb0P\x7f\xf2\xc8\x19\xeb+4\xae\xa9+}2Q?\xcez \x8b-\xb5t\x80\x07\x17\x84-k?\xcb\x15\xb8\x9a\x93\xf8r\x17\x03\xdbtA*0\xca\xb9z\xaf\xd3\x94@\x8b\x88\xf3\xfb\x06\xd1\x8a\x88\xd6\x95!\x0cw\x08\xc37[)\xd1\xb4\xa1\xa1\x03\xe4\xf4\x88\xa3\x8c\xec'\xc9\xb3\x22(\x0e\xce\x18\xf1\x04\xe9\xc4!\xe4\xd3\xc6+\xbf\xc7\xa5\x84\xfd\xaf\x93\xb3F\xb4\xb9\xe7\xe9}\x8c@'\xbc\xc5\x81\xecQ\xd02\xa3\xd5\xcb\x98\xb8\xba\xd8\xad\xcc\x14\xe3\xe8\xcb\x19\x09\xf1W\xca\x05\xbe\x5c\x80\xdc\xd0\xab\xc0z\xb7\x9d:\xcax\x849\xda\xbb\x7f\xd5d\x1a[\xfb\x05\x05\xf5\x91W*\xf0\x91#\x97\xaf\xc8?\xc57\x89\x1e\x83\x88G_\x19~\xbb\xc6\xc1\xa5\x14\xc4O\xe7\x1d\x90\x85(\x92\x8a\xc4\xd2\x8f\xff\x15\x95\xc1\x1b\x1f\x05\xf2\xe8ehd\xcb\xb8f\x9d\xf5\x8c\x9b\xdc\xff\x00W\xa7\xaf&\xcb\xf4LX\xb4\xc8\xe6}U5J\xf59\xa3\x99J7\xc0\xa2\xf4|\xbfp\xd6\xc1\xc7b\x12:\xccj\x00\x91G\xd6\x06(b\xe2\xc6\x01r\xcc\x0d\x17$\x10\x15\xd5;v3s\xcac**\x8d\xb1/8@h/E\x02\xc2T\xb9k\x05\xb8t5\xcf%\xc1j\xfb\xdd\xce\xd4f\xf7\x95y\xcf\x9a\xa7\xd7\xf1S\xe8\x89>\xbd}\xea%\xb0\xbbf \xbc\xaeFF\xd8M=>\xaa)\xa6E\xc0\xc8\x0d-\x10EF\x9e\xec\xe6\x84\x04\xe8\x04\xd0T8b\xc5\xa2\xe4\x9d\xc7\xbb\x7f8\x85\x11t!\xe8\x1a\x11\xcf\xa4\x9cK\xf1t8M\xcb\xe6\x93A\xa9\x8c\xe2z\x5c:\xa7\xbe\xcc\x93A\xd5R\xafy\xd4\xe2\xa1~\xe0\xc9}t{-\xea\xa2\xd6S\x0dASkL\xe1|ZI`W|\xb3w\x138g\x01\x1a\xd6HD\x1b\x15\xeat8W\x1f\x1f\xf8\x96\xcd\x14\xabPw\x92\xc3<\xc9~\x19cf\x02\xfd\xe3\xd1\xa0\x8bx0\xf5\x8c-\xa8H\xe02\x98(\xde2j\xd1s*:W#\x8bQvt\x14\x96\x88(\xbf>\x89\xaa\xb6n\x90Q\xe1\x16!\xe55f\x12d\x17\x05\x04\xd1\xfd\x09\x918\x0b\xe1-U\xd4\x87k!|iH \x8e\xd8o\x00(@4\x22-!d\xe5\x8a\x15U(X\xa6\xa4\x1b)~C\x9e\xe7\x98\xf5o)\xf6\x16\xa1d\xae[\xfc4\xb8\xd9\x81\x1e\xd5\xfd\xbb\x11\xcc\x9dV@h:\xbe\xd6\xa6P\x14\xf2\xb0B=\x003\x85\x9d\xbf\x8dWx\xfd7\x8cm\x91\xba\xd2\xb64\xaf}\x86\xc2\xe7\xc2\xf1p\xc9\x0eDc=\xb5Q\xc2uZ4W~\xda\xb6L\xea\xa0\x0az'\xb9\xae\x87l\xf4\xda\x1c\xc0\xe4#Xr\xbdgKurV,\x9e\x1d)e0\xae6\xaa\xbf\xff\xea\x08\x12\xf9\xbb\xcf\xf2\xf7\x86\x1d\xa8\x82\xd7\xa0\xd2\xa1\xbbyZ\xe5\xa8\x05o.\x98\xd8\xd1m\xbe\xce\x00\xa8!}\xccT\xcb\x19\x0e\xa6I\xe8\xc4\x00$\xc6\x91n.\x04a\xd3\xfe\xc4\xae|\x17>\x96K1\x12\xfb^%\xd9\xb0(\xfc\xe5\x09b\xa5U\x92;sl\xb7X\xa2\xabf\x02n\xfbG_\x06\xcf\xee\x84O\xbe\xf6\xc3Q\x1d\x8fc\x8d[\x9c\xaf\x05\x0d#q\x80\xec\x87\x07Y\xc7\x10\xcd]sS\xa1\xf49\x225\xb1\xa8!\x0f:Q\x9f\x82\xb1P\x8cE\x864\x82\x972dt\x9e\x90B\xa0\xbbi(!\xcdN\xa2Ti\x84k\xe3c\xb1\xf7\xc1g(\x5c\xb2\x1a0\x9dRO\x1f\x15\xa6\xe9\xbc\x13\x95\xab\xb7)\xa4\xa6\xa1\xcd\xf5l\xd8x\x7f9\xa3\x86\x08\x9d~\xbd57\x15F\x83\xaf\xf8g\x5c\x18\x06\xf5\xb7a\x1cY-\x84\xf8!=]H\xa9\xf9\xbd\xe0\xe3$\xa1\x0eZM\xa4w\xb7/E\xddi1\x03\xf1r\x9c\xddCR\xce\xdf\xd0\xaaYOK\xfd\xbaO\x99\xa7\x05b\x22\xa3\x1dn\x00A\xde\xf1\xf3\xa6\xadp\xef\xfa\xd3\xd2K;\x09d\x80\xd5\x96[M\xd6\xb9}2[\xd45\x0a\x91D\xdd\x07e\xd4a*$\xe4H\x87\xf1\x0d\xe2\xd4\xe5\x8d\xc9W\xa8\xc3\xe1yI\x99p\xff\xad\xa1\xe8\xb8\x999v\xe6\xc0\xdc\xa6\xaf\xf2\xb6\x1a\xd7_\x07\x17/\xd4\xd1=\xe7\xb3\xa3\xcaPT\xc1y8\x07%\xfc1\x9e\xa2\xfe\x87v\x0f\x97gu>\xdb(,\xa7"; + +fn main() { +} + +/* + +(module + (export "f" (func $func0)) + (func $func0 (param $var0 i64) (param $var1 i64) (result i64) + (local $var2 i64) + i64.const 0 + loop $label0 (param i64) (result i64) + local.get $var0 + local.get $var1 + i64.ctz + local.tee $var2 + i64.rotl + i64.xor + local.get $var1 + i64.const 1 + local.get $var2 + i64.rotl + i64.xor + local.tee $var1 + i64.eqz + i32.eqz + br_if $label0 + end $label0 + ) +) + */ +fn func0(a: i64, mut b: i64) -> i64 { + let mut c: i64; + let mut x: i64 = 0; + loop { + c = b.trailing_zeros() as i64; + b = b ^ 1i64.rotate_left(c as u32); + x = x ^ a.rotate_left(c as u32); + + if b == 0 { + break; + } + } + x +} + +/* + (func $func1 (param $var0 i64) (param $var1 i64) (result i64) + (local $var2 i32) + i64.const 0 + loop $label0 (param i64) (result i64) + local.get $var0 + call $func0 + local.get $var2 + i64.load + i64.xor + i32.const 1016 + i32.const 8 + local.get $var2 + i32.add + local.tee $var2 + i32.and + br_if $label0 + local.tee $var0 + local.get $var1 + i64.le_u + if + i64.const 1 + local.get $var1 + i64.add + local.set $var1 + end + local.get $var0 + i32.const 2040 + local.get $var2 + i32.and + if (param i64) (result i64) + local.get $var1 + i64.sub + local.set $var0 + i64.const 0 + br $label0 + end + end $label0 + ) + */ +fn func1(mut var0: i64, mut var1: i64) -> i64 { + let mut var2: i32 = 0; + + let mut x = 0; + 'label0: loop { + println!("{var0} {var1} {var2}"); + x = func0(x, var0) ^ i64::from_le_bytes((&DATA[var2 as usize..var2 as usize + 8]).try_into().unwrap()); // TODO wrong parameter order? TODO address or index? + + var2 += 8; + if var2 & 0b1111111000 != 0 { + continue 'label0; + } + + var0 = x; + + if var0 as u64 <= var1 as u64{ + var1 += 1; + } + + println!("b{var0} {var1} {var2}"); + if var2 & 0b11111111000 != 0 { + var0 -= var1; + x = 0; + } else { + break; + } + } + var0 +} + +/* + +(module + (memory $memory0 1 1) + (export "f" (func $func1)) + (data (i32.const 0) "j\e9~\9c\f5@\16[\ac|\f0O\9e\f0\18,\80Y\f23`\dd8\ceS\9e>\b6\15o\c7 \22\97\8dRF\c6\9e+Q\f4`\b1\df\82\9d\c3p\86\1fQ\17~\b5_\a4\88\87\a8\ffK\ec=\d8\13\a8Z\9a\8e\e7\5c\06\efz\d3\ff\cc\e98@L\12\03\c5\ea\cd\ea#\e3q$R\e3\dbh7Tg\99\95\94z$F\ab)\94\016M\89+]\8e^\1a\04v\04\e8e\f4\cb\17\c5\eb\93SS\81\e8\fe\abT\1c\97\bc`\e2\b2Z\d1\8d\a6\c2!\fa k:\e9\85\f3\e7\1b(\80X\8bL\88<\a6\aa\bb\87W;=WN<%\dfh\cdg\da5\fcs\d7\8f\8a\1e\e2\adl\f2\919Q\c6\ddE\0d\d0{\96\c1\f0\89\dc\e38\d9\97\c0\81D\8483Q\a9\c7\9c*G\8b\04o\b8\e34K\cd\ec(\83\89#S\ce\da\bb\bcn\9b\bbl\1eh\f3@\d7yp^\fc\81\fbh\17x\bb\aa\f8x?\95@I\86\a6T\9c\15qDP\e4\1a.\bb\88\d1\c2p\d9C?\ca{\17\1f\1f\e2,\a6\0fK\c4\977EH5#\a4:\d9\e5\0c\c8/c\91h\ac\13\90\5c;B\b6\8f\18\f9\c0\84g\d9\d4\d6\83\a1\e9\98\f8\f8\a9\af2\16\f14\f0\b4Z\22#+\fa\17\d0i\82\b3\df:\97\07\b2qq\8b\b9D\f8^\cb\05\18\05\c9t@h\8ap\d4\09\b5\ec\09\10}\fc\1e\e3?*\0e>I\10\22\86\d8\89\95\9f$}\d2\b4f\f5\abF\90Bu\fc\c6!\ac\89\ea\f8\c7(Q\a6\80\cfqXs1\abL\ca\ea\0c\0c\cd\c2g\fd\fbMc\9e%\ed\ac7\cb+\11>E\89\cf\bf\cbc\f9\ac6\8f\87\ce\1bwT\bfv_;\14\8dL\c2\ae\10E\f6\83T\0cn\83\d7\92\aa\ce\c9\07\c8\8e\5c_\ca\9a\8d\ae\e5P\c8\c58\a0,\ddVSZ]\c1KK\ad;\fe\f5\cf&\ba\bc\99\02\d5f\e0\07\ac\ad\e6\ca\b5\eb\0d\f3;xsD\9a\bb\e6\a6B\e91\e7\dd\12\9c\9eL\0d\8e\96\c3*0=I\f43\bf4\1c\cb\ff\dd\15\88\b8pj\97\15\a2\f8Xl\8b\05\9a\fc\ad\cc\93(\c6\7fq\db\fe\16\13\d3\8ac\16F/\09\0d'\d9\d9\f0\86l:\9e\1f\f2\ef\92\06\b5\e8\92\c7a\a2\c4\5c\e3:\0f\f1<\d6E\0aw \8e\fa[S\aa\a2\125\1a\a8\1f\bc\93\0fJ\b0\96n\ba\85\9e\ba\8b\e6K\1c2]JGT\cb\ec\0a\03>\1d%\06\18d^d\8bY\a0\a2b\f5\a8\c8\f1[\ed<\b6\c5\c0D\f1*d,j{\17OVk\00h\90a\a7p\f7\b0!Ns\c9\10\8c\c7\e3\ae\1f1\0fw\a5u\16\94\caK\088\80\989\0e|4mE%w~B\a6\dd\81\dd\9b\b9E\e1P\ceJ\8dF\9bP\94\b2}\c2\fc\ec\e3\c8\f4N\ac\fe%a\91\e4~|\e5K\b0P\7f\f2\c8\19\eb+4\ae\a9+}2Q?\cez \8b-\b5t\80\07\17\84-k?\cb\15\b8\9a\93\f8r\17\03\dbtA*0\ca\b9z\af\d3\94@\8b\88\f3\fb\06\d1\8a\88\d6\95!\0cw\08\c37[)\d1\b4\a1\a1\03\e4\f4\88\a3\8c\ec'\c9\b3\22(\0e\ce\18\f1\04\e9\c4!\e4\d3\c6+\bf\c7\a5\84\fd\af\93\b3F\b4\b9\e7\e9}\8c@'\bc\c5\81\ecQ\d02\a3\d5\cb\98\b8\ba\d8\ad\cc\14\e3\e8\cb\19\09\f1W\ca\05\be\5c\80\dc\d0\ab\c0z\b7\9d:\cax\849\da\bb\7f\d5d\1a[\fb\05\05\f5\91W*\f0\91#\97\af\c8?\c57\89\1e\83\88G_\19~\bb\c6\c1\a5\14\c4O\e7\1d\90\85(\92\8a\c4\d2\8f\ff\15\95\c1\1b\1f\05\f2\e8ehd\cb\b8f\9d\f5\8c\9b\dc\ff\00W\a7\af&\cb\f4LX\b4\c8\e6}U5J\f59\a3\99J7\c0\a2\f4|\bfp\d6\c1\c7b\12:\ccj\00\91G\d6\06(b\e2\c6\01r\cc\0d\17$\10\15\d5;v3s\cac**\8d\b1/8@h/E\02\c2T\b9k\05\b8t5\cf%\c1j\fb\dd\ce\d4f\f7\95y\cf\9a\a7\d7\f1S\e8\89>\bd}\ea%\b0\bbf \bc\aeFF\d8M=>\aa)\a6E\c0\c8\0d-\10EF\9e\ec\e6\84\04\e8\04\d0T8b\c5\a2\e4\9d\c7\bb\7f8\85\11t!\e8\1a\11\cf\a4\9cK\f1t8M\cb\e6\93A\a9\8c\e2z\5c:\a7\be\cc\93A\d5R\afy\d4\e2\a1~\e0\c9}t{-\ea\a2\d6S\0dASkL\e1|ZI`W|\b3w\138g\01\1a\d6HD\1b\15\eat8W\1f\1f\f8\96\cd\14\abPw\92\c3<\c9~\19cf\02\fd\e3\d1\a0\8bx0\f5\8c-\a8H\e02\98(\de2j\d1s*:W#\8bQvt\14\96\88(\bf>\89\aa\b6n\90Q\e1\16!\e55f\12d\17\05\04\d1\fd\09\918\0b\e1-U\d4\87k!|iH \8e\d8o\00(@4\22-!d\e5\8a\15U(X\a6\a4\1b)~C\9e\e7\98\f5o)\f6\16\a1d\ae[\fc4\b8\d9\81\1e\d5\fd\bb\11\cc\9dV@h:\be\d6\a6P\14\f2\b0B=\003\85\9d\bf\8dWx\fd7\8cm\91\ba\d2\b64\af}\86\c2\e7\c2\f1p\c9\0eDc=\b5Q\c2uZ4W~\da\b6L\ea\a0\0az'\b9\ae\87l\f4\da\1c\c0\e4#Xr\bdgKurV,\9e\1d)e0\ae6\aa\bf\ff\ea\08\12\f9\bb\cf\f2\f7\86\1d\a8\82\d7\a0\d2\a1\bbyZ\e5\a8\05o.\98\d8\d1m\be\ce\00\a8!}\ccT\cb\19\0e\a6I\e8\c4\00$\c6\91n.\04a\d3\fe\c4\ae|\17>\96K1\12\fb^%\d9\b0(\fc\e5\09b\a5U\92;sl\b7X\a2\abf\02n\fbG_\06\cf\ee\84O\be\f6\c3Q\1d\8fc\8d[\9c\af\05\0d#q\80\ec\87\07Y\c7\10\cd]sS\a1\f49\225\b1\a8!\0f:Q\9f\82\b1P\8cE\864\82\972dt\9e\90B\a0\bbi(!\cdN\a2Ti\84k\e3c\b1\f7\c1g(\5c\b2\1a0\9dRO\1f\15\a6\e9\bc\13\95\ab\b7)\a4\a6\a1\cd\f5l\d8x\7f9\a3\86\08\9d~\bd57\15F\83\af\f8g\5c\18\06\f5\b7a\1cY-\84\f8!=]H\a9\f9\bd\e0\e3$\a1\0eZM\a4w\b7/E\ddi1\03\f1r\9c\ddCR\ce\df\d0\aaYOK\fd\baO\99\a7\05b\22\a3\1dn\00A\de\f1\f3\a6\adp\ef\fa\d3\d2K;\09d\80\d5\96[M\d6\b9}2[\d45\0a\91D\dd\07e\d4a*$\e4H\87\f1\0d\e2\d4\e5\8d\c9W\a8\c3\e1yI\99p\ff\ad\a1\e8\b8\999v\e6\c0\dc\a6\af\f2\b6\1a\d7_\07\17/\d4\d1=\e7\b3\a3\caPT\c1y8\07%\fc1\9e\a2\fe\87v\0f\97gu>\db(,\a7") +) + */ + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn func0test() { + assert_eq!(2275218980137066521, func0(823376445, 2933488917)); + assert_eq!(7026402047137357602, func0(3691543355, 2547548462)); + assert_eq!(1360720565456786886, func0(1631669653, 1943537758)); + assert_eq!(6206853381339280580, func0(3418720847, 3281877132)); + assert_eq!(3821249963754522024, func0(1289221960, 3243927869)); + assert_eq!(882431475059032604, func0(367193564, 4097712529)); + assert_eq!(4926161117160240706, func0(3436171671, 4292693206)); + assert_eq!(3115965114924228534, func0(1753842422, 3687497057)); + assert_eq!(8734691127450451974, func0(4044078733, 2197737550)); + assert_eq!(2943203761612760392, func0(1244650136, 2964402935)); + assert_eq!(6772758496796810062, func0(3178786959, 2277874162)); + assert_eq!(164002738127771409, func0(2431906895, 67872835)); + assert_eq!(2534635611824557864, func0(1526866754, 2980150036)); + assert_eq!(2281422676663357779, func0(1974321509, 1338155343)); + assert_eq!(4809582189839732169, func0(2231376997, 2155687005)); + assert_eq!(7997326223635490910, func0(3333279658, 2464875795)); + assert_eq!(564698454155766592, func0(3819982240, 158798722)); + assert_eq!(150358408295203874, func0(1407059918, 178123531)); + assert_eq!(2950877544101808616, func0(4027467880, 2130465393)); + assert_eq!(7433963866346235715, func0(3231972439, 2337659549)); + assert_eq!(97718272192598598, func0(135080626, 727604235)); + assert_eq!(2019072571720999028, func0(2117949580, 1226677547)); + assert_eq!(4064354319484950360, func0(1685177180, 3015516490)); + assert_eq!(829978590409745198, func0(1043018378, 1910838971)); + assert_eq!(1343743912543815608, func0(1931247249, 1611122744)); + assert_eq!(344344082533737885, func0(1622600431, 499885623)); + assert_eq!(2258376149702545739, func0(1116642871, 2119709157)); + assert_eq!(870036298768927356, func0(510143124, 2841548211)); + assert_eq!(2291729428506812433, func0(822131093, 2919079061)); + assert_eq!(1942041239928076416, func0(2427487936, 866869806)); + assert_eq!(4413542076532948168, func0(1142011985, 4204104264)); + assert_eq!(7725503794949940832, func0(2652944930, 3355197488)); + assert_eq!(572731058715430966, func0(346457467, 1706449986)); + assert_eq!(771384575430546132, func0(349225434, 2383068914)); + assert_eq!(6720471466404264298, func0(2734432761, 2683021530)); + assert_eq!(10114228482972006, func0(6443214, 4037181469)); + assert_eq!(1462086330404018156, func0(2261477748, 692328079)); + assert_eq!(4248125061804235846, func0(1462734411, 3599520562)); + assert_eq!(438254739184660816, func0(150017636, 3401841844)); + assert_eq!(924924009899234107, func0(1890984405, 796124759)); + assert_eq!(1583433247430081905, func0(1511929045, 1335064885)); + assert_eq!(344452189567184841, func0(287207665, 1216709049)); + assert_eq!(8408046965142065312, func0(4005765152, 2223455621)); + assert_eq!(2340737587100291955, func0(2250772451, 1140023921)); + assert_eq!(1011391340612719836, func0(1260502354, 1055586398)); + assert_eq!(4539082446856232019, func0(1275385147, 3900684569)); + assert_eq!(2073697442264457591, func0(807071233, 3145796471)); + assert_eq!(464008672190170508, func0(2328300556, 203128353)); + assert_eq!(1750720338177427574, func0(2052773661, 1464133406)); + assert_eq!(2818450916558278418, func0(1307950731, 2266653278)); + assert_eq!(3087550251367439382, func0(3748440942, 1748394149)); + assert_eq!(31065924273406873, func0(28131655, 1185107827)); + assert_eq!(1637091247100653372, func0(2583625587, 719595348)); + assert_eq!(1187803888684817137, func0(955126175, 3662511859)); + assert_eq!(1076693608643937976, func0(2415810454, 479440468)); + assert_eq!(886932995053456855, func0(1998857853, 785872531)); + assert_eq!(4041577507147387694, func0(1989558127, 2317016338)); + assert_eq!(3195373375008716592, func0(1544958382, 2317403752)); + assert_eq!(4344034197574385581, func0(1163146903, 4257380511)); + assert_eq!(4548739690401687331, func0(1816152237, 3218195687)); + assert_eq!(5688846906041887124, func0(4241496484, 3500572141)); + assert_eq!(3748650067680712929, func0(1670205605, 2600188565)); + assert_eq!(4489150664351988267, func0(3047056993, 1752871819)); + assert_eq!(3552290940876679256, func0(2242739114, 1630483100)); + assert_eq!(8404550793217443760, func0(2273636432, 3969930983)); + assert_eq!(1348409384823762177, func0(1007538615, 3531004331)); + assert_eq!(3545691341191605002, func0(1926409210, 3055258457)); + assert_eq!(1627039133669989128, func0(1103530570, 1540713044)); + assert_eq!(337319684340642581, func0(1071722095, 936379311)); + assert_eq!(2488111028592156108, func0(1363867182, 2686974746)); + assert_eq!(1838074366800239376, func0(1986957250, 1524007560)); + assert_eq!(375258788906303722, func0(3294750862, 201986535)); + assert_eq!(6087525133192784177, func0(3763006281, 3772000697)); + assert_eq!(1250706533780855424, func0(2592292625, 618017408)); + assert_eq!(1567055362944800611, func0(821519937, 3400471971)); + assert_eq!(3839668165238544140, func0(4126323486, 1498898218)); + assert_eq!(5154501295052475800, func0(3753548118, 4004509476)); + assert_eq!(276252029851915445, func0(2169263253, 128333985)); + assert_eq!(4303845948374636936, func0(1219406786, 4048413508)); + assert_eq!(8955630451326320612, func0(2308854182, 4142939790)); + assert_eq!(3950342623314748312, func0(2635951912, 1687868271)); + assert_eq!(1347719876603310184, func0(978203467, 3440087448)); + assert_eq!(4325169701035756612, func0(2021926123, 2172822044)); + assert_eq!(1123560531444408352, func0(2415743450, 510384080)); + assert_eq!(302367434318115088, func0(1695451564, 510042140)); + assert_eq!(5425253682140093808, func0(2454871170, 2220814520)); + assert_eq!(1440678434476164920, func0(941214316, 3378223338)); + assert_eq!(6738906437434918068, func0(3161261478, 2254805142)); + assert_eq!(1200367617776126876, func0(4107039252, 866921035)); + assert_eq!(4356587871866293326, func0(1202192174, 4225386321)); + assert_eq!(918255447474733459, func0(1296132779, 932888873)); + assert_eq!(286069664049683456, func0(1223290368, 238264130)); + assert_eq!(737264942432347260, func0(3336065407, 411345540)); + assert_eq!(360102161648468383, func0(332266485, 1087376259)); + assert_eq!(531469479175514084, func0(837869778, 752496162)); + assert_eq!(5488021351449658331, func0(4053318219, 3627637233)); + assert_eq!(2195117409397730144, func0(1281698344, 1888304668)); + assert_eq!(763462177913700116, func0(323851131, 3063765996)); + assert_eq!(4040244555080779916, func0(1658170916, 3092066683)); + assert_eq!(3852821034638912936, func0(1753274702, 2278544668)); + assert_eq!(4041373326734813864, func0(2263341818, 1915177764)); + assert_eq!(1963702993615069667, func0(1919728625, 1382000883)); + assert_eq!(4877789904824206100, func0(3361201225, 4026614708)); + assert_eq!(30179695802284800, func0(63431512, 768970272)); + assert_eq!(1449592659987634229, func0(1612461201, 1615233253)); + assert_eq!(4261547527047212185, func0(1965217825, 2238776249)); + assert_eq!(8423406086031164118, func0(4281074866, 2643256195)); + assert_eq!(1782123918688200992, func0(1418043636, 2071419944)); + assert_eq!(1047489370443739329, func0(2764618499, 454805695)); + assert_eq!(2934673406450453408, func0(4134873516, 2100643096)); + assert_eq!(5650705393643171844, func0(2943771772, 3197035875)); + assert_eq!(1038767850510879704, func0(1267164458, 1060555612)); + assert_eq!(4204937883267119488, func0(1646378432, 3071105114)); + assert_eq!(411829728143907900, func0(4104299556, 243262903)); + assert_eq!(7871739648472512000, func0(3892839244, 2908343424)); + assert_eq!(2984675312994870904, func0(3160475925, 1312301464)); + assert_eq!(21035103484703632, func0(162635036, 150285900)); + assert_eq!(3251194670058000317, func0(2379882081, 1573406045)); + assert_eq!(110250149841963592, func0(534172326, 343271772)); + assert_eq!(7078970850659721868, func0(2244340883, 3275910212)); + assert_eq!(2725272366739724240, func0(1949499772, 3488175260)); + assert_eq!(595614546781317578, func0(532656446, 3304604751)); + assert_eq!(4117176559172186460, func0(2144016228, 2527036959)); + assert_eq!(2632599442184004850, func0(1195711793, 2649908626)); + assert_eq!(8283259829447755662, func0(4242278674, 2515258815)); + assert_eq!(8576464463094299940, func0(3718522222, 2812874342)); + assert_eq!(1921698232043823400, func0(1109599650, 1775528660)); + assert_eq!(1154402324203904172, func0(1476051740, 1384187285)); + assert_eq!(455463673979035594, func0(214276239, 2219875006)); + assert_eq!(2384533312140370925, func0(3175026621, 1491797393)); + assert_eq!(1891967452146534940, func0(990728773, 2804246444)); + assert_eq!(8051443749879688498, func0(2551326570, 3398973725)); + assert_eq!(610551727018460416, func0(2081384706, 815047296)); + assert_eq!(986636632557619796, func0(902596084, 1155254281)); + assert_eq!(1091429410910539584, func0(478991904, 2657795994)); + assert_eq!(8776624415569207203, func0(2977137159, 3727366797)); + assert_eq!(382219229381305275, func0(646537673, 767549155)); + assert_eq!(3879007306152627155, func0(4284337903, 1578339205)); + assert_eq!(5640927286993029844, func0(3876557086, 3452918622)); + assert_eq!(1998985482433578131, func0(2042549347, 1566472785)); + assert_eq!(2168046308224159248, func0(1457939723, 1686938480)); + assert_eq!(4466965408553605840, func0(2457856272, 1956085501)); + assert_eq!(1067663693542443033, func0(977508429, 1128940005)); + assert_eq!(8860666141481256660, func0(3985583770, 2544156338)); + assert_eq!(745516573917847823, func0(480123883, 4004776317)); + assert_eq!(6438483768859797674, func0(3143262762, 2324635713)); + assert_eq!(3254090421191095208, func0(3620879492, 1728307114)); + assert_eq!(1340483629302253568, func0(3428653120, 980314656)); + assert_eq!(2411345400251493265, func0(2399278795, 1158313383)); + assert_eq!(6651644068546691056, func0(3699784488, 3449780262)); + assert_eq!(6292307452484462516, func0(2235066222, 2861630718)); + assert_eq!(681387698627300975, func0(1650061851, 943566413)); + assert_eq!(8383786330681871058, func0(3338203166, 3051808523)); + assert_eq!(8556366266451367696, func0(3754229852, 2794985068)); + assert_eq!(5879489647181272672, func0(2452073158, 3072584464)); + assert_eq!(3254887619117977121, func0(2252534289, 1507028785)); + assert_eq!(1891777769572061084, func0(3873245929, 716324604)); + assert_eq!(716988359874547192, func0(3201491255, 361375432)); + assert_eq!(8773276214145328288, func0(4115558392, 2244003260)); + assert_eq!(1557858294476708064, func0(2354601828, 686262392)); + assert_eq!(6517694501844039680, func0(3398545856, 3549470752)); + assert_eq!(4066267488082735696, func0(1758402864, 2805295731)); + assert_eq!(3595903941024271292, func0(1413796534, 4117469210)); + assert_eq!(4741134743254315904, func0(2325717790, 2310876736)); + assert_eq!(266074381549681662, func0(1881177169, 146222494)); + assert_eq!(6058711024417491765, func0(2204038291, 2879243651)); + assert_eq!(1718993490673745892, func0(2459229789, 712918100)); + assert_eq!(2716445728417641712, func0(1233340744, 2239562798)); + assert_eq!(8745705085685282468, func0(2695032622, 3270520678)); + assert_eq!(240884880814460464, func0(185694725, 2073299440)); + assert_eq!(370338321743340060, func0(1927878045, 500448908)); + assert_eq!(5573963629959711288, func0(3708488923, 4134848168)); + assert_eq!(541758693581570993, func0(3382379489, 181618257)); + assert_eq!(1815967889786955188, func0(1429495489, 2108672692)); + assert_eq!(4041604264929827155, func0(3249256207, 1600814245)); + assert_eq!(952003732340514366, func0(337370794, 3918218595)); + assert_eq!(4332233817724496798, func0(1812951086, 3063286953)); + assert_eq!(1758658545102429502, func0(2746796405, 1065632262)); + assert_eq!(540269665119950416, func0(1585842566, 433209112)); + assert_eq!(2331775051124288019, func0(2065558545, 3398949923)); + assert_eq!(307490286585000947, func0(461817349, 1948269263)); + assert_eq!(960292366624895421, func0(1543654715, 1053356755)); + assert_eq!(2157515180864683421, func0(3298669099, 751530403)); + assert_eq!(487852033197913091, func0(1927701481, 350032635)); + assert_eq!(2984595772390019960, func0(3545686998, 1800861044)); + assert_eq!(3392204407324397988, func0(2173364313, 1589689028)); + assert_eq!(1687946440198430352, func0(4177494640, 944731779)); + assert_eq!(39287165401589762, func0(1991068770, 57386801)); + assert_eq!(1100437088382813246, func0(1577671925, 878786054)); + assert_eq!(862950049948957457, func0(1662101853, 887867421)); + assert_eq!(2332695340952914938, func0(3280480578, 2122372317)); + assert_eq!(462363662690671169, func0(545694885, 866050229)); + assert_eq!(3052771912967790776, func0(1459213981, 2241587096)); + assert_eq!(920814936415458234, func0(2134665779, 718464502)); + assert_eq!(70831990903737178, func0(853535583, 85914286)); + assert_eq!(1344859749633130679, func0(2157802473, 628177775)); + assert_eq!(3428977288760135037, func0(1791083763, 3251293275)); + assert_eq!(1721466933995983702, func0(3738274869, 847866702)); + assert_eq!(3384471763492985384, func0(3414274072, 1814298819)); + assert_eq!(2192502073650024941, func0(2890196027, 852102243)); + assert_eq!(1733565508298695626, func0(2792063762, 1051404813)); + assert_eq!(1532023292037786912, func0(2370877684, 689901864)); + assert_eq!(559614790651608242, func0(291650478, 2063352163)); + assert_eq!(5619240326630354996, func0(2727081038, 3031714974)); + assert_eq!(6190657267302765724, func0(4192667396, 4161955943)); + assert_eq!(679208445002198844, func0(2116906316, 933317045)); + assert_eq!(1430495629237040970, func0(2195270695, 656040174)); + assert_eq!(1758830525608466631, func0(4006564763, 801380245)); + assert_eq!(4625807642296379568, func0(3476098436, 4085248172)); + assert_eq!(4248813050677024640, func0(1756035124, 2867110752)); + assert_eq!(3429570552635333824, func0(1589085520, 2209700604)); + assert_eq!(4750842979111071920, func0(2336421774, 2284355496)); + assert_eq!(1021348587074499006, func0(608186674, 2119354007)); + assert_eq!(2650438524731897405, func0(3278912387, 1894748779)); + assert_eq!(1351722393614577911, func0(3873437327, 814233097)); + assert_eq!(2686403937481637342, func0(2194661374, 1272337201)); + assert_eq!(164459815905328414, func0(3372082866, 121763335)); + assert_eq!(5470234883889678, func0(376314766, 21646145)); + assert_eq!(2007298046738591390, func0(612987929, 3310593550)); + assert_eq!(7579170471480569320, func0(2919769722, 3772899844)); + assert_eq!(3968476460573009653, func0(1948625227, 2832099163)); + assert_eq!(4340678797444951998, func0(3191445514, 1807390099)); + assert_eq!(7832464371503197486, func0(2994368086, 4218339445)); + assert_eq!(982620286037513066, func0(619247894, 1613434459)); + assert_eq!(1809487919217160166, func0(2934499234, 1059642243)); + assert_eq!(2227413677592354988, func0(905868166, 3140412082)); + assert_eq!(1958340477793776136, func0(1004501418, 2866117396)); + assert_eq!(590440659472964824, func0(420902903, 4146813608)); + assert_eq!(3970885299515062746, func0(3846845727, 1344431534)); + assert_eq!(164475886718180190, func0(1020415601, 447873278)); + assert_eq!(1062027837126423760, func0(3032151014, 412430936)); + assert_eq!(429619033882122664, func0(1621666264, 448531563)); + assert_eq!(5465767171073422050, func0(3345982579, 3812216638)); + assert_eq!(347658486012260024, func0(1478516335, 350366280)); + assert_eq!(6440862574948199618, func0(3782557837, 4098062842)); + assert_eq!(1270604464903699470, func0(1751112038, 1890371245)); + assert_eq!(3990241783457318167, func0(2091942305, 3077482359)); + assert_eq!(3095411610704251470, func0(3928441734, 1952104285)); + assert_eq!(1069952684789806615, func0(3188097795, 432905997)); + assert_eq!(1549510620786047412, func0(3674778462, 878268622)); + assert_eq!(1429727667635371368, func0(599105724, 2443677518)); + assert_eq!(889132028527773456, func0(3417495052, 292769468)); + assert_eq!(1109664055108497692, func0(1000278385, 1272878172)); + assert_eq!(2990842971177857614, func0(1226065605, 2998674070)); + assert_eq!(4894085341085904512, func0(2249201185, 2177891968)); + assert_eq!(1859036770300358570, func0(4014348786, 756516621)); + assert_eq!(2451518505915255646, func0(1232096701, 2578825494)); + assert_eq!(2205946059708622052, func0(1641031343, 1385566060)); + assert_eq!(3607888246633189888, func0(1166920549, 3333224960)); + assert_eq!(3409366258867729020, func0(1443805428, 2514027643)); + assert_eq!(4122535696483767818, func0(3152364589, 1628836498)); + assert_eq!(6584536497103126554, func0(3137221462, 2391924179)); + assert_eq!(3245159287932023751, func0(3847638123, 2061142533)); + assert_eq!(4609438965157669332, func0(1542442263, 3568168668)); + assert_eq!(1564728155339319015, func0(630777123, 3179001917)); + assert_eq!(5978365295179605808, func0(2304428272, 2920878405)); + assert_eq!(972742158466457616, func0(2128754666, 803902760)); + assert_eq!(7625899292046064160, func0(3175610740, 4224628456)); + assert_eq!(2983624539619229192, func0(1937022356, 3968084458)); + assert_eq!(5497434190094288088, func0(3313445210, 3951395836)); + assert_eq!(199197631139916560, func0(4086182872, 120131182)); + assert_eq!(2273250670276286060, func0(1194807547, 2073909380)); + assert_eq!(3494453182023216983, func0(2980208217, 1921386399)); + assert_eq!(180270644748392130, func0(1880151370, 249058581)); + assert_eq!(1020687423684566464, func0(3162858504, 403593144)); + assert_eq!(291374995101965483, func0(1173506421, 289551719)); + assert_eq!(6167212839858030320, func0(2237591192, 2940713642)); + assert_eq!(4488824941658136448, func0(2081720640, 2173211942)); + assert_eq!(2206242177574492224, func0(1713226528, 1456526962)); + assert_eq!(8500616454723219552, func0(2185519189, 3894612448)); + assert_eq!(236078952304886049, func0(378394021, 1030145365)); + assert_eq!(3791741142945851634, func0(3533006866, 1079459825)); + assert_eq!(7674861032202750752, func0(3854222824, 2901179220)); + assert_eq!(88593838880189540, func0(479139274, 434522266)); + assert_eq!(3731498617958392025, func0(1735328383, 2168827627)); + assert_eq!(4957327058688802720, func0(3654712552, 3979332484)); + assert_eq!(7586489473623616224, func0(2154882788, 3537252856)); + assert_eq!(5143234237995849488, func0(3236767920, 4099088967)); + assert_eq!(60814690151151476, func0(498610518, 176543174)); + assert_eq!(2494338124570153837, func0(1448467319, 2933168959)); + assert_eq!(733832228618837770, func0(349844931, 2236268166)); + assert_eq!(7844804996009623654, func0(2464193762, 3261818019)); + assert_eq!(5518707381922347405, func0(3166848573, 2843734769)); + assert_eq!(3829929761992272984, func0(2414509228, 1861674690)); + assert_eq!(4094706142515960729, func0(2986286595, 1687969655)); + assert_eq!(345618432118279752, func0(2992767531, 175111800)); + assert_eq!(798568757356499947, func0(560702467, 1518587225)); + assert_eq!(352626257298633474, func0(968320474, 856724989)); + assert_eq!(3570273852672598722, func0(2820928119, 2049887638)); + assert_eq!(3735523136603139435, func0(2522699243, 1753191297)); + assert_eq!(2181915330402303264, func0(3484973196, 717809720)); + assert_eq!(5723993708054967808, func0(2513790800, 2315259616)); + assert_eq!(1727680221548818127, func0(1566988465, 1115445087)); + assert_eq!(5273304784419026355, func0(2456730373, 2151011983)); + assert_eq!(3175623972632029919, func0(1830002671, 3306360913)); + assert_eq!(4447007966674445116, func0(1371836457, 3321051740)); + assert_eq!(3899839142503181672, func0(3608266446, 1171579836)); + assert_eq!(1993558991869011729, func0(2567198675, 845022879)); + assert_eq!(5933240954264181656, func0(2457851548, 2952909370)); + assert_eq!(4597526342616153493, func0(2919650215, 1673911591)); + assert_eq!(1547485473755000787, func0(1760812609, 1863559443)); + assert_eq!(5683553362672329498, func0(3872366101, 3449241586)); + assert_eq!(494769461427248570, func0(4031818898, 199052341)); + assert_eq!(3797776063332282449, func0(1433727141, 3859327461)); + assert_eq!(6588752316325819690, func0(3869514115, 4125126630)); + assert_eq!(391832171403485124, func0(857584047, 838712332)); + assert_eq!(880029967602815000, func0(426878809, 2412794200)); + assert_eq!(7593890349902382474, func0(2745495614, 3940158127)); + assert_eq!(6926956260679816736, func0(3899644216, 3109462188)); + assert_eq!(1731149291020412220, func0(876866220, 2632937341)); + assert_eq!(5660738063111627788, func0(3596395324, 4225200661)); + assert_eq!(1788936071689986148, func0(3206921692, 984843907)); + assert_eq!(874573593734676768, func0(2550097481, 463767584)); + assert_eq!(1182143537867310080, func0(1700803120, 2062119872)); + assert_eq!(8393752603899524206, func0(4260442877, 2681042150)); + assert_eq!(1782297911710605872, func0(672832912, 4215320203)); + assert_eq!(7052660320218896402, func0(4169531158, 2817369775)); + assert_eq!(5966122521260465752, func0(3293987770, 3266008572)); + assert_eq!(493613352831265072, func0(531058236, 1522941332)); + assert_eq!(3308367842185720871, func0(1700999837, 3515347331)); + assert_eq!(5582146373973471156, func0(3128843194, 2892662498)); + assert_eq!(5197577012378903625, func0(3966451265, 3456919561)); + assert_eq!(5076235779695138180, func0(3233955540, 4155667461)); + assert_eq!(5041956745231058732, func0(3137053980, 3153402677)); + assert_eq!(449029540692164234, func0(1948118349, 397191634)); + assert_eq!(3786442463749305066, func0(1190621674, 3628889985)); + assert_eq!(3440549460014024670, func0(2106866191, 3857895490)); + assert_eq!(1528962614547299152, func0(1868126580, 1767828516)); + assert_eq!(2508532949574004150, func0(2992004222, 1505434157)); + assert_eq!(2327634121549296275, func0(3925694773, 1758870655)); + assert_eq!(7257180057129154944, func0(3850715328, 3160777378)); + assert_eq!(9216621579985580286, func0(3048160665, 3608126574)); + assert_eq!(5907475734858138670, func0(4014836531, 3770002874)); + assert_eq!(47299776568275280, func0(427576720, 206045037)); + assert_eq!(174074512819035664, func0(3410244060, 119887148)); + assert_eq!(3116298418657666199, func0(1271130465, 3180671159)); + assert_eq!(130740941844403068, func0(1612373183, 92275332)); + assert_eq!(2227746384385250634, func0(1193198319, 2119181822)); + assert_eq!(3563068769544832918, func0(3221281694, 1128691149)); + assert_eq!(108980518478507848, func0(860113823, 143009496)); + assert_eq!(112146113283630940, func0(2816955165, 66355916)); + assert_eq!(3209498496158786286, func0(3954084329, 2142877022)); + assert_eq!(6193441409059035240, func0(2647124952, 2994962307)); + assert_eq!(6226869574356444159, func0(3227595467, 3372069325)); + assert_eq!(4843814881447501259, func0(2962522447, 3198222413)); + assert_eq!(426630101308735846, func0(3846010890, 262073999)); + assert_eq!(1853798696792617694, func0(566897337, 3373327502)); + assert_eq!(1966838142700480504, func0(993591588, 2862230030)); + assert_eq!(3639461145036136796, func0(4106490356, 1360639763)); + assert_eq!(1925534994360371342, func0(1147025403, 1817816938)); + assert_eq!(3634425862933673426, func0(1644186057, 2299475010)); + assert_eq!(2464111059642867566, func0(1247843818, 2667617035)); + assert_eq!(2350153312285279665, func0(1624158905, 4256796873)); + assert_eq!(2850531047138812302, func0(4189932329, 1798351294)); + assert_eq!(1486082696691782420, func0(2909702661, 585213700)); + assert_eq!(2649806316519305424, func0(2086760360, 3701034034)); + assert_eq!(2170383500442791041, func0(903084605, 3189606445)); + assert_eq!(1643767853711382158, func0(3858601673, 1031921150)); + assert_eq!(7725199539164948432, func0(4105452632, 2982393158)); + assert_eq!(3006749785472129805, func0(4054198601, 2110049381)); + assert_eq!(3984594387247199320, func0(2954774136, 2129671437)); + assert_eq!(5454653628742070890, func0(2455422454, 2241343915)); + assert_eq!(949909218755351823, func0(683140463, 1971658401)); + assert_eq!(6648710440848711212, func0(2219107298, 3174795830)); + assert_eq!(4387467003412738779, func0(1218197297, 4018893323)); + assert_eq!(3949143420499952336, func0(1231611404, 3230742124)); + assert_eq!(3102058349658132183, func0(4003938445, 1953020995)); + assert_eq!(5824364053818140888, func0(3432057350, 3447619620)); + assert_eq!(402448503266966352, func0(326694335, 1464707568)); + assert_eq!(283343416853086680, func0(1703441535, 171480680)); + assert_eq!(173366152475041984, func0(1675104601, 243296960)); + assert_eq!(1463526334944962896, func0(1101672560, 1358900359)); + assert_eq!(1724958009142895972, func0(1486151998, 1176283158)); + assert_eq!(323339694521048878, func0(1268794622, 325573177)); + assert_eq!(133197901901887265, func0(1204124321, 121339265)); + assert_eq!(7382917723094673096, func0(2395289908, 3307541578)); + assert_eq!(8654315346180184172, func0(2335856465, 4257754540)); + assert_eq!(4311595948954631948, func0(3152244583, 1695148084)); + assert_eq!(467947919192110215, func0(410485381, 1144582571)); + assert_eq!(1384759049206803106, func0(1860478875, 2053250542)); + assert_eq!(3698677069390789259, func0(1279301893, 3679739607)); + assert_eq!(4531388231301396529, func0(1146026651, 4096482775)); + assert_eq!(4166032737587999215, func0(2101349261, 2479848667)); + assert_eq!(479757380231767088, func0(1597221410, 534270872)); + assert_eq!(7782016477278872683, func0(4010439465, 2732134291)); + assert_eq!(1948994408556721464, func0(1502469948, 2113318002)); + assert_eq!(2102159745664376400, func0(2395642360, 953667038)); + assert_eq!(2642717006354016012, func0(2798113475, 1572922372)); + assert_eq!(604911721254394712, func0(392763210, 3037489500)); + assert_eq!(429728672387013272, func0(2027601540, 500792166)); + assert_eq!(466284266395859144, func0(1641644241, 287173192)); + assert_eq!(1099356420782787958, func0(673397154, 1658675531)); + assert_eq!(950895133767130432, func0(668641744, 1641024548)); + assert_eq!(1859758453069873974, func0(617495778, 3596757131)); + assert_eq!(3115416191363345932, func0(1111415988, 2849757511)); + assert_eq!(8050334533677165614, func0(3199023989, 4155509078)); + assert_eq!(5895330320397640798, func0(2438826278, 3020568405)); + assert_eq!(3190559650972604056, func0(4051408356, 1934783030)); + assert_eq!(2335118622826822339, func0(1906469141, 3651426575)); + assert_eq!(2816742440934079210, func0(3520534590, 2120434815)); + assert_eq!(7139426485652885536, func0(2310677648, 3421395218)); + assert_eq!(2590376858790817216, func0(2306917787, 1125249344)); + assert_eq!(6294487202012800747, func0(2287846107, 2763422865)); + assert_eq!(8359525168348312140, func0(2881210561, 3554125644)); + assert_eq!(6117909894342257884, func0(3432620892, 3258090273)); + assert_eq!(6436650438434468207, func0(3308309453, 3646739867)); + assert_eq!(880951093317656186, func0(484708015, 2977790766)); + assert_eq!(1414248317312558054, func0(1588004195, 1453516002)); + assert_eq!(5697171718473588768, func0(3393198812, 3802264920)); + assert_eq!(6614446099871830436, func0(2761600581, 2518684020)); + assert_eq!(8945002808370977863, func0(3698929917, 3200002627)); + assert_eq!(3336225862125073203, func0(1553481479, 2147616189)); + assert_eq!(32679099365301580, func0(2721265711, 14446868)); + assert_eq!(3887138410226351508, func0(1179637660, 3693794039)); + assert_eq!(4547498452923665171, func0(1153882173, 4065719335)); + assert_eq!(2361900330903588432, func0(2434686844, 1209203772)); + assert_eq!(2080524629819565339, func0(2018761491, 1314209657)); + assert_eq!(2546577658919579190, func0(1808047510, 3888309297)); + assert_eq!(3764704395585504420, func0(1614033174, 2668865694)); + assert_eq!(4305669791953995676, func0(2972346993, 1674976988)); + assert_eq!(4360497647571473560, func0(2070695446, 2263774500)); + assert_eq!(217184807489458877, func0(424742517, 591044329)); + assert_eq!(2014088650827117220, func0(3525440701, 574499220)); + assert_eq!(2830852220292963908, func0(2909241532, 1587758627)); + assert_eq!(556966598590061799, func0(270115159, 2078895953)); + assert_eq!(4770082142318552280, func0(3359319032, 4065054509)); + assert_eq!(1988861666768413044, func0(659322078, 3459224046)); + assert_eq!(364202173505635776, func0(324918592, 1606708395)); + assert_eq!(5945478796003399675, func0(3933819603, 3769154969)); + assert_eq!(6439171132929748834, func0(2352118709, 3165429546)); + assert_eq!(617767329022097699, func0(1297973605, 607453695)); + assert_eq!(1741785644062149091, func0(1721059209, 1148203195)); + assert_eq!(5213773654996979073, func0(2744368367, 3166404307)); + assert_eq!(1840861617135866370, func0(2691549593, 1007234994)); + assert_eq!(3779258810997091568, func0(1681056560, 2429201685)); + assert_eq!(5131409734634441709, func0(2577772155, 2486518307)); + assert_eq!(600263778220748814, func0(3300740794, 529174883)); + assert_eq!(7059140477185270686, func0(3186873993, 3992661998)); + assert_eq!(215889863818598036, func0(3987772602, 127597490)); + assert_eq!(6907707261119618328, func0(3080061800, 2345370407)); + assert_eq!(1757682468643705459, func0(559271605, 3304350623)); + assert_eq!(1851485148460057080, func0(1066884376, 2859761397)); + assert_eq!(4440647653985702104, func0(2565981335, 1919983528)); + assert_eq!(451548364804342852, func0(2899997602, 268364162)); + assert_eq!(7192849386323380608, func0(3016573408, 3776911764)); + assert_eq!(2671662474848282871, func0(1075622309, 2490436347)); + assert_eq!(2103837083036266128, func0(1654495982, 1529540760)); + assert_eq!(6929832478717489952, func0(2402632232, 3356167604)); + assert_eq!(6663356815334017212, func0(2495687282, 2823166734)); + assert_eq!(831238524972775156, func0(1279703910, 698400438)); + assert_eq!(2714394132811664969, func0(1856552189, 4284675653)); + assert_eq!(939094430713284398, func0(1326010766, 812532337)); + assert_eq!(6828476440126435403, func0(3222021051, 3606536657)); + assert_eq!(874437249986550928, func0(4152851184, 362337483)); + assert_eq!(7473914318486340176, func0(2777531641, 4110247888)); + assert_eq!(4573578983396633728, func0(3116886956, 1861865440)); + assert_eq!(8408067264874841115, func0(4254699181, 2666454143)); + assert_eq!(102665758690983949, func0(166656421, 731389577)); + assert_eq!(3116290802993597152, func0(3535717130, 1814553520)); + assert_eq!(1075801001314835648, func0(470669920, 2295768770)); + assert_eq!(799105677043490186, func0(482274513, 4062744746)); + assert_eq!(628331459690883792, func0(2123019926, 856480408)); + assert_eq!(43528617938543256, func0(20150359, 2202040680)); + assert_eq!(1759919367703070358, func0(1436778690, 2036016363)); + assert_eq!(3551268864306481812, func0(3323811348, 1092452769)); + assert_eq!(78459986133614048, func0(1980484904, 114988044)); + assert_eq!(4690362599354536, func0(113665476, 120510794)); + assert_eq!(1724855956340929567, func0(583792937, 3080129991)); + assert_eq!(250063219286081792, func0(309887616, 825034922)); + assert_eq!(4484720894018751571, func0(1582972675, 3743506737)); + assert_eq!(129155055150900984, func0(62895960, 2398198861)); + assert_eq!(7644813940101280882, func0(3606622230, 2201641663)); + assert_eq!(4222071416571147124, func0(2683711620, 2139692925)); + assert_eq!(7403866903426819811, func0(2614571645, 3652136279)); + assert_eq!(3288023904694387728, func0(4272829557, 1985390160)); + assert_eq!(743332948690662105, func0(1284583189, 774967805)); + assert_eq!(1605519659285646920, func0(1507146392, 1089342423)); + assert_eq!(1119737655160722323, func0(444347995, 3055193465)); + assert_eq!(165300604864957136, func0(2127571147, 227732784)); + assert_eq!(4227648558739649664, func0(4027160970, 1263408960)); + assert_eq!(23771463911008541, func0(101288679, 432883775)); + assert_eq!(5071019533961269486, func0(2955447630, 3079286513)); + assert_eq!(5782285926531788288, func0(2775422328, 2218228288)); + assert_eq!(1123086122057207795, func0(438010733, 3050042039)); + assert_eq!(462453352622903972, func0(1911404209, 400364132)); + assert_eq!(759175622207799420, func0(1004676948, 2010448867)); + assert_eq!(7174566392434848652, func0(2689619133, 4177649756)); + assert_eq!(8024554970815363232, func0(4277251010, 2956941904)); + assert_eq!(3586796453350635613, func0(3528754871, 1305153071)); + assert_eq!(716299206502621504, func0(374575426, 2705855648)); + assert_eq!(2628184141572208768, func0(2875985344, 1514031478)); + assert_eq!(374341695695249432, func0(255529220, 4179288454)); + assert_eq!(1919739629069752160, func0(1988611499, 1364577824)); + assert_eq!(202035790036497791, func0(76919085, 2780898283)); + assert_eq!(1981062709390295715, func0(3579392937, 582364571)); + assert_eq!(3653060100725424177, func0(1125028491, 3482937479)); + assert_eq!(3255814583860007336, func0(2742354920, 1237042729)); + assert_eq!(261195369002632266, func0(2742550095, 109640638)); + assert_eq!(248760936616729444, func0(1017373079, 390839948)); + assert_eq!(1379299000317064896, func0(812412056, 4024020424)); + assert_eq!(315103690810603767, func0(284171331, 1175790957)); + assert_eq!(4613580130684264260, func0(2424301369, 2453403812)); + assert_eq!(8840391425047513056, func0(2781180696, 3269360340)); + assert_eq!(2656300754874885776, func0(2601208071, 1156852272)); + assert_eq!(1658627213996457161, func0(778656109, 2177966037)); + assert_eq!(8546293918947861628, func0(2642641668, 4214661471)); + assert_eq!(8858153802654084786, func0(3746124070, 3026835047)); + assert_eq!(187754628109357844, func0(1814572669, 234078820)); + assert_eq!(309402747996338570, func0(1629033495, 509708750)); + assert_eq!(7288324631331914464, func0(4088588518, 2818363856)); + assert_eq!(886742636323861553, func0(556728469, 1628084533)); + assert_eq!(9159247376663192, func0(172371064, 90295845)); + assert_eq!(4629491896586287332, func0(3063759180, 3218559623)); + assert_eq!(1604014465397402960, func0(1751689912, 1727401518)); + assert_eq!(3376729054096161204, func0(1521271519, 2364588636)); + assert_eq!(2206022078489840424, func0(2709085437, 822858184)); + assert_eq!(107338948033020176, func0(276488144, 398096317)); + assert_eq!(1924503528045604212, func0(750138329, 4110670740)); + assert_eq!(6121499544549568397, func0(3693024449, 3495034445)); + assert_eq!(5477439504046660637, func0(2403801031, 2531529503)); + assert_eq!(4885111907649357592, func0(3822966589, 3700671672)); + assert_eq!(3240844705600759386, func0(2528845171, 1349900758)); + assert_eq!(2496457627827240158, func0(2167851126, 1171997741)); + assert_eq!(5589406371718614, func0(2943585, 2715094678)); + assert_eq!(487941920366610576, func0(1900966247, 343303728)); + assert_eq!(399663220764840562, func0(207703599, 3632655030)); + assert_eq!(7106379551859402286, func0(4048798807, 2902009730)); + assert_eq!(3446381326060339626, func0(3966009615, 2031841566)); + assert_eq!(216398252627098741, func0(76155643, 3669822315)); + assert_eq!(2565706596304335168, func0(1398119192, 2703968536)); + assert_eq!(8086394062312383368, func0(3380921590, 3005173212)); + assert_eq!(4336843869955734576, func0(1411800844, 3487059972)); + assert_eq!(372048907370030905, func0(352911171, 1192219991)); + assert_eq!(364032366825454688, func0(255331280, 4247095854)); + assert_eq!(98184437105228900, func0(60270850, 3758853938)); + assert_eq!(3955778875704677028, func0(1457200580, 3910337369)); + assert_eq!(3522261510346046569, func0(3053048277, 1893094733)); + assert_eq!(7908000676665236923, func0(2961744845, 4200044799)); + assert_eq!(2094481739978900352, func0(827156209, 3082414976)); + assert_eq!(4760394739250299428, func0(2740680516, 2896892633)); + assert_eq!(4267402182700018264, func0(2866339691, 1808189192)); + assert_eq!(273858847910920180, func0(388149835, 880039820)); + assert_eq!(4590189607374278464, func0(3302804032, 1455497013)); + assert_eq!(8613720796834212156, func0(2997067890, 3306180558)); + assert_eq!(1989477620252852022, func0(1527598498, 2093296747)); + assert_eq!(2570801956815456032, func0(1483846180, 3047897480)); + assert_eq!(2791354498686132714, func0(1645769618, 3910621917)); + assert_eq!(4441439740424547786, func0(3451673242, 1472181449)); + assert_eq!(5950981168191011924, func0(3649320573, 3691663908)); + assert_eq!(3788544125558312544, func0(1325609568, 3272496289)); + assert_eq!(1528855978278406712, func0(3295185196, 850897354)); + assert_eq!(6330338938177597113, func0(4144943241, 4027972529)); + assert_eq!(8148877518727233608, func0(2994198455, 3400937368)); + assert_eq!(2408476831841572518, func0(4079797967, 1678949322)); + assert_eq!(3455329584421877766, func0(1416508134, 2458107345)); + assert_eq!(5243576307918972738, func0(4052998571, 3586428334)); + assert_eq!(2566913319942619485, func0(2103346013, 3441236481)); + assert_eq!(1213426958996050644, func0(4279275441, 827279124)); + assert_eq!(320115752068198416, func0(449420912, 1915187643)); + assert_eq!(1304503038703106814, func0(543356566, 2439852749)); + assert_eq!(1912989978926302732, func0(2752079014, 979248994)); + assert_eq!(2944985508975587974, func0(3127283805, 1309958702)); + assert_eq!(4206929653219854072, func0(3261213746, 1494395996)); + assert_eq!(3523072546174689158, func0(2388490182, 1696481249)); + assert_eq!(3203918533589519120, func0(3071340159, 1139844400)); + assert_eq!(662488956006071364, func0(3431247772, 495772683)); + assert_eq!(2858037651531688484, func0(2215188100, 1295918633)); + assert_eq!(4387218581580276724, func0(2639216006, 1942226646)); + assert_eq!(498932155654031328, func0(405944784, 1273548918)); + assert_eq!(6795023453381633478, func0(3671386971, 3429199954)); + assert_eq!(1860310628894204604, func0(1517961730, 2008887134)); + assert_eq!(305172512109618180, func0(455889334, 1938739726)); + assert_eq!(3079057827274749208, func0(1938649690, 3839514524)); + assert_eq!(1123957492061889236, func0(1621444460, 734518283)); + assert_eq!(101900646280025772, func0(56231897, 3463462668)); + assert_eq!(2438307288236494876, func0(3387239484, 2029232281)); + assert_eq!(7536108024986179551, func0(3308408217, 2561725079)); + assert_eq!(491903049534679319, func0(405417299, 1225019517)); + assert_eq!(861116868020411790, func0(373345018, 2401416771)); + assert_eq!(4530618806595095782, func0(4162265058, 1097159779)); + assert_eq!(1130466975104908710, func0(1023272459, 1178363666)); + assert_eq!(4560708238496500214, func0(1866290478, 3141197269)); + assert_eq!(2977986038634177701, func0(1124230515, 2732045331)); + assert_eq!(2890650920579604670, func0(1810694919, 3557257554)); + assert_eq!(2141098559569235838, func0(3967341647, 541544994)); + assert_eq!(1090650768396546763, func0(1244571397, 973287831)); + assert_eq!(76648113298751501, func0(1843467629, 125164001)); + assert_eq!(1630004319893056151, func0(3488931837, 899625555)); + assert_eq!(8565516408289496975, func0(4199419477, 2628548787)); + assert_eq!(7944262515015239174, func0(3981928881, 2923507110)); + assert_eq!(1323782380728260574, func0(2309881050, 649335419)); + assert_eq!(434726103336114639, func0(255120001, 2841923663)); + assert_eq!(6022683314687793200, func0(3574654928, 3551029431)); + assert_eq!(5291537132874400579, func0(3853128235, 3349812633)); + assert_eq!(5507000741441429303, func0(3477940161, 3801898103)); + assert_eq!(4053683243348307546, func0(4104275790, 1325785519)); + assert_eq!(472891556919672976, func0(1421905882, 479118504)); + assert_eq!(1461730001037645184, func0(3613418416, 902549384)); + assert_eq!(8439329632384531632, func0(3118499448, 3440192922)); + assert_eq!(3729854460223476168, func0(1448429818, 4193106900)); + assert_eq!(2248901375594896177, func0(578239239, 4154589707)); + assert_eq!(1582385900138989488, func0(1632521886, 1681108200)); + assert_eq!(3826213174957537678, func0(2985503554, 2067476647)); + assert_eq!(4909776093291832, func0(904063208, 14909827)); + assert_eq!(562487683858956776, func0(1472406200, 406601839)); + assert_eq!(1822698994295163541, func0(2526889319, 896985831)); + assert_eq!(3242258080608042872, func0(1393155834, 2440699436)); + assert_eq!(843088796616274327, func0(3118355093, 272758923)); + assert_eq!(350380165011701056, func0(169906280, 3025609416)); + assert_eq!(6482746072603825092, func0(4260026924, 3900608199)); + assert_eq!(3558339210796729558, func0(3552957433, 1290321606)); + assert_eq!(2482522885543542629, func0(2121276903, 3469056759)); + assert_eq!(1502276394932309348, func0(1045576067, 4084075228)); + assert_eq!(3193516249629652013, func0(4139743019, 1892490675)); + assert_eq!(3605494052580631340, func0(3826139829, 1583278876)); + assert_eq!(317554549634165574, func0(334903267, 1220227970)); + assert_eq!(6766402938426848210, func0(4026847430, 3903285319)); + assert_eq!(443765735057742328, func0(1515962271, 486379272)); + assert_eq!(8227958075891336276, func0(2509906454, 4244895094)); + assert_eq!(1046903751408644092, func0(1920800884, 586347643)); + assert_eq!(317272548618983328, func0(2068761352, 406273396)); + assert_eq!(361839928091908146, func0(140531805, 2802874602)); + assert_eq!(7214088363797987768, func0(3510148360, 2454585431)); + assert_eq!(41268866037288417, func0(1002258569, 108795945)); + assert_eq!(2213259581391720472, func0(1914980152, 1299264717)); + assert_eq!(2423938935974165343, func0(2125541563, 3353833533)); + assert_eq!(2571411258464574960, func0(1565740688, 3204969799)); + assert_eq!(38605534328029347, func0(2592201191, 18992941)); + assert_eq!(2747081803671221556, func0(1861720139, 4122392524)); + assert_eq!(4020549990485267272, func0(1674832919, 2421523352)); + assert_eq!(561233685089051645, func0(518141587, 1156663995)); + assert_eq!(3954928896985822472, func0(1826847142, 2213587004)); + assert_eq!(57497474012534722, func0(767815047, 125505782)); + assert_eq!(794900642886967112, func0(377306636, 2212939342)); + assert_eq!(1396445710543262962, func0(875329739, 4169205118)); + assert_eq!(407288484457294736, func0(1274166148, 348452196)); + assert_eq!(177056880645978584, func0(156467772, 1149359674)); + assert_eq!(48661332948497602, func0(933592826, 111187725)); + assert_eq!(3403835942987339714, func0(1690919093, 3751886602)); + assert_eq!(6950524138415637172, func0(3782520695, 3085825532)); + assert_eq!(397884239267814344, func0(445894678, 1697579516)); + assert_eq!(1652318226523599758, func0(2210400753, 755619374)); + assert_eq!(6796994911096741788, func0(2711827428, 2614650063)); + assert_eq!(159562634417028204, func0(1297268051, 155740900)); + assert_eq!(4343993304537566858, func0(1645397738, 2816471793)); + assert_eq!(5933438406025843600, func0(3209334269, 2665203536)); + assert_eq!(8481651695964614256, func0(3796864472, 2350615594)); + assert_eq!(6210978852743727565, func0(2518167671, 3170180831)); + assert_eq!(1215613455131613273, func0(1713335473, 2048260969)); + assert_eq!(552429516654894365, func0(3981120253, 159370081)); + assert_eq!(3900342269535305122, func0(2636148018, 1698992265)); + assert_eq!(1196641610495613274, func0(3775620495, 924088334)); + assert_eq!(644952771444430339, func0(501991229, 3725602551)); + assert_eq!(2444836718749822859, func0(1645584161, 4289702891)); + assert_eq!(609577737681480, func0(158091468, 5216110)); + assert_eq!(6530618479580850624, func0(2403678560, 3099755402)); + assert_eq!(3066525468095159640, func0(4175297044, 2082466798)); + assert_eq!(10376218787774318, func0(2063167022, 13864161)); + assert_eq!(3628817445653842582, func0(1541038705, 3945936566)); + assert_eq!(2767030295921031604, func0(3298795422, 1978238478)); + assert_eq!(3124075222562500130, func0(3806927990, 1927641623)); + assert_eq!(4593515628373318240, func0(1230139680, 3784778763)); + assert_eq!(23029050978871722, func0(129863753, 524890362)); + assert_eq!(1286360944094905672, func0(2997296446, 769689708)); + assert_eq!(8493922395701327108, func0(4292927580, 2654191691)); + assert_eq!(7519646265602506582, func0(3072940510, 4133376141)); + assert_eq!(1667046382755903168, func0(818635936, 3532009806)); + assert_eq!(3403854751261818103, func0(4045444515, 1990694477)); + assert_eq!(74537310785533293, func0(2991814861, 49980449)); + assert_eq!(6211739113946988068, func0(3081710245, 2673565556)); + assert_eq!(1687749243076882185, func0(2471169803, 727707951)); + assert_eq!(4054441100824201655, func0(1821271233, 2865574903)); + assert_eq!(8306871274617265746, func0(2665404687, 4078416278)); + assert_eq!(3655431443632129676, func0(4003712635, 1505316900)); + assert_eq!(419661221226497121, func0(2926077759, 152604515)); + assert_eq!(6701922304689110160, func0(3176783164, 2253953708)); + assert_eq!(6392987485494140880, func0(3840596204, 4078440524)); + assert_eq!(1853657984807349558, func0(2206418709, 870850670)); + assert_eq!(1533408776077285855, func0(2546972581, 788260083)); + assert_eq!(1830191231324604404, func0(3855661556, 801123713)); + assert_eq!(2178603539343213500, func0(1353049986, 1612659550)); + assert_eq!(2537232780872824122, func0(1352331499, 2760542406)); + assert_eq!(8163791836131488076, func0(3606455548, 2706411189)); + assert_eq!(1100288496149320802, func0(1247525914, 998922477)); + assert_eq!(2745050095963503332, func0(3998496658, 1625279970)); + assert_eq!(2007649168137497473, func0(2866386861, 977669821)); + assert_eq!(318304702241300895, func0(1029666535, 822054601)); + assert_eq!(3002829971830215990, func0(1636101326, 3351895717)); + assert_eq!(3412593204024616744, func0(3984155916, 2017445318)); + assert_eq!(538895953737505723, func0(348408749, 1858922847)); + assert_eq!(967952335835043541, func0(1688352509, 622919369)); + assert_eq!(315820282820258322, func0(1063972581, 841308730)); + assert_eq!(4070090396127280240, func0(1482880904, 3401566254)); + assert_eq!(8565233277536069014, func0(3199321635, 3465218738)); + assert_eq!(224756054879272989, func0(3866340541, 95481633)); + assert_eq!(1365644313630637902, func0(3200774075, 703227306)); + assert_eq!(1826838785381143616, func0(944834416, 3106138220)); + assert_eq!(1730337662159246944, func0(978057200, 3098910890)); + assert_eq!(1870402601013270085, func0(1992703021, 1528770313)); + assert_eq!(2207495121372982784, func0(4196070144, 574581050)); + assert_eq!(1480752793635483952, func0(2828349765, 603956976)); + assert_eq!(1116023908331408616, func0(513032004, 2196365082)); + assert_eq!(8113647549246332262, func0(3091636074, 3299075935)); + assert_eq!(756797341121703633, func0(1673520765, 842301437)); + assert_eq!(1131174835562809354, func0(308336175, 3855243198)); + assert_eq!(5912423929011732624, func0(3984294417, 3866835344)); + assert_eq!(39642944140571365, func0(44332983, 1444943399)); + assert_eq!(2289147471396024286, func0(2629714142, 983007361)); + assert_eq!(5150873468918355648, func0(2962505664, 3045181677)); + assert_eq!(1886683567232970998, func0(605908629, 3359233966)); + assert_eq!(8685210974498515924, func0(3912467167, 2535516412)); + assert_eq!(54100315976436318, func0(535204151, 168493010)); + assert_eq!(3862708117517718560, func0(2392307464, 1868960004)); + assert_eq!(1236129659150626294, func0(1673926943, 2076549978)); + assert_eq!(890473679075136256, func0(688074176, 2123300916)); + assert_eq!(3104825440856317166, func0(1985023573, 3936185686)); + assert_eq!(4129792465246017888, func0(1308578152, 4128200636)); + assert_eq!(598546585681677458, func0(4103074083, 435246798)); + assert_eq!(4195194777234942812, func0(1442222090, 3546297462)); + assert_eq!(1186689603005453024, func0(2007934452, 1786842776)); + assert_eq!(85763224323422977, func0(3905717353, 51935529)); + assert_eq!(2125905792429400148, func0(1420521396, 1794970969)); + assert_eq!(7594886574013839918, func0(3938022211, 2749477274)); + assert_eq!(2822895860927682074, func0(1522029866, 2772780537)); + assert_eq!(1544002914547342585, func0(3703575487, 889024075)); + assert_eq!(7184274632418745883, func0(4192465987, 2693224393)); + assert_eq!(8362762975605511714, func0(3339839166, 3021798675)); + assert_eq!(341958651073118819, func0(206917775, 3786399349)); + assert_eq!(3426040861808420034, func0(2421035610, 1435130717)); + assert_eq!(300602294634399142, func0(4015049699, 218454562)); + assert_eq!(1150542769424318323, func0(285947433, 4027706955)); + assert_eq!(190164010168428222, func0(117815593, 3761426702)); + assert_eq!(991974643415506982, func0(2275848750, 454545709)); + assert_eq!(265459041805652440, func0(2978728364, 101877090)); + assert_eq!(3631935834178032804, func0(2039788147, 2768282460)); + assert_eq!(2010993643127733662, func0(2327545089, 880450462)); + assert_eq!(726222233152908868, func0(749645316, 1243179025)); + assert_eq!(2187342209211609004, func0(661252374, 3864204354)); + assert_eq!(1328460006090375142, func0(1225905479, 1085982330)); + assert_eq!(4525014405810506688, func0(1390701120, 3482531063)); + assert_eq!(860563049782118685, func0(462537653, 3357223689)); + assert_eq!(4217280421393841424, func0(1315180072, 4245565962)); + assert_eq!(4771097447456160104, func0(2579150552, 2683495875)); + assert_eq!(726917923852884045, func0(3663346347, 454460179)); + assert_eq!(924237891839760592, func0(525800678, 2918374488)); + assert_eq!(33457941248930314, func0(47200130, 818077125)); + assert_eq!(7487623379825410304, func0(3985092400, 3061367024)); + assert_eq!(4451917604570386392, func0(2656917572, 1895239318)); + assert_eq!(223933442029062274, func0(233459201, 1230148738)); + assert_eq!(350936311922357243, func0(1055912183, 888054261)); + assert_eq!(821744094681912075, func0(1957517999, 1053072557)); + assert_eq!(1681506824442221653, func0(1915321089, 2115957589)); + assert_eq!(8066118979194009014, func0(2440935734, 3337847745)); + assert_eq!(8332455676178691328, func0(2587942336, 4112081756)); + assert_eq!(6311081256779047556, func0(3127824482, 2462463778)); + assert_eq!(4861050849926498638, func0(2856583418, 2813708707)); + assert_eq!(412118501672632791, func0(1864590221, 413093443)); + assert_eq!(2837228334140298808, func0(1866932529, 4036088504)); + assert_eq!(369959726682782063, func0(2646370715, 197244877)); + assert_eq!(1924219631900387622, func0(1017954682, 3078455335)); + assert_eq!(1523096706775368228, func0(1027462234, 4133962666)); + assert_eq!(6052318944292123864, func0(3716917912, 3675832889)); + assert_eq!(3706354363532715015, func0(1123529349, 3404323627)); + assert_eq!(1771258249580110788, func0(929455971, 2473751868)); + assert_eq!(6229523256495690457, func0(3460896291, 3330936343)); + assert_eq!(153103417302791597, func0(176639623, 1383282703)); + assert_eq!(1358253247071214540, func0(2151375092, 633191751)); + assert_eq!(4451917931570624896, func0(3712331088, 1512672760)); + assert_eq!(1817451173348146207, func0(580846025, 3337855591)); + assert_eq!(4083337477384481714, func0(2414902587, 1960404190)); + assert_eq!(1746448498110808186, func0(1104771078, 1640121323)); + assert_eq!(1811749934442391677, func0(537210059, 3376056803)); + assert_eq!(3122846889760556355, func0(1321659661, 3036666599)); + assert_eq!(9147869923242351629, func0(3678135173, 3155668777)); + assert_eq!(2453009113817020748, func0(2727223935, 1364433364)); + assert_eq!(320089281842637330, func0(1903440514, 438761033)); + assert_eq!(1565616127386769032, func0(1788039160, 1864581491)); + assert_eq!(1036923734868458562, func0(276779450, 3839540717)); + assert_eq!(134424585484511399, func0(913549363, 169438029)); + assert_eq!(8716472888939175980, func0(3338885205, 2783665308)); + assert_eq!(8288622766487616556, func0(2922760860, 3624264149)); + assert_eq!(7835038569786921644, func0(2570579526, 3450730738)); + assert_eq!(2503471391660145800, func0(2377964908, 1132614382)); + assert_eq!(3928395794655800724, func0(2098484404, 2969765033)); + assert_eq!(2072182000837503520, func0(1519266800, 1695450982)); + assert_eq!(8265973739358637130, func0(3537698594, 2726117621)); + assert_eq!(1802493032785571299, func0(1032247613, 2725268375)); + assert_eq!(19619185861751454, func0(10039482, 2437837899)); + assert_eq!(2215468640369760894, func0(785872870, 3588761349)); + assert_eq!(3572529816541817015, func0(1398253819, 4261383781)); + assert_eq!(370307757439420710, func0(733144854, 571532489)); + assert_eq!(3845981760053323678, func0(1734910270, 2476192753)); + assert_eq!(1484295529764415160, func0(3417707480, 857640133)); + assert_eq!(128892999448872122, func0(70566093, 1883284130)); + assert_eq!(5837381070791843116, func0(3872595146, 3898394990)); + assert_eq!(3478736982000091976, func0(1787136808, 2597168253)); + assert_eq!(4306153282790701648, func0(3195871408, 1713448875)); + assert_eq!(44033129449486889, func0(29672223, 3383065115)); + assert_eq!(6700480050728099263, func0(3110864417, 2158105695)); + assert_eq!(6408674341283751728, func0(3119310895, 2332512848)); + assert_eq!(3051318078736446972, func0(2817390882, 1188559902)); + assert_eq!(1972989709924562971, func0(780351859, 4095020889)); + assert_eq!(8048658988730391304, func0(2172392103, 3733992152)); + assert_eq!(2433326231168527560, func0(1191895996, 2314226422)); + assert_eq!(2262298967858370092, func0(1670842444, 1418824969)); + assert_eq!(7803938417708341091, func0(2484042097, 3328979443)); + assert_eq!(7539322157117594696, func0(2333062132, 3731408138)); + assert_eq!(2705973594988999680, func0(1327534528, 2310364144)); + assert_eq!(455498720733482479, func0(494244741, 1523229411)); + assert_eq!(4003355075929112936, func0(2003101608, 2951934137)); + assert_eq!(145619321149625216, func0(105857344, 4119966742)); + assert_eq!(1322726589776158064, func0(1413122850, 1516370232)); + assert_eq!(4281575980138241722, func0(2004761533, 2189949122)); + assert_eq!(16281594880419440, func0(696430160, 28229099)); + assert_eq!(6774353018767117994, func0(3263840733, 3574506962)); + assert_eq!(25908512765000440, func0(23153497, 1167041208)); + assert_eq!(119772304291037529, func0(266315289, 793442625)); + assert_eq!(3876561449444878992, func0(1969783400, 2751698474)); + assert_eq!(235128318431245156, func0(3248079130, 82986442)); + assert_eq!(7492929719824884655, func0(3538012839, 2505512153)); + assert_eq!(55196351724228315, func0(379005127, 241792773)); + assert_eq!(9106944950460834758, func0(2375564262, 4113610993)); + assert_eq!(173999956604907592, func0(2054170120, 234339529)); + assert_eq!(944771168620951036, func0(2376235561, 461253276)); + assert_eq!(6746362651807636992, func0(3252394112, 3554295292)); + assert_eq!(2136327602749129599, func0(1167588285, 1890022299)); + assert_eq!(647259156825987205, func0(1235154857, 667525837)); + assert_eq!(181347495823061120, func0(3044547080, 76587536)); + assert_eq!(1541749083112940234, func0(1401157942, 1204429947)); + assert_eq!(627036784648830094, func0(2556878738, 302767359)); + assert_eq!(1490452281418649367, func0(2951928321, 572172567)); + assert_eq!(2606982472231538634, func0(1947010026, 3413349457)); + assert_eq!(3199162885566252185, func0(1236031391, 2799143243)); + assert_eq!(373308689736776416, func0(1806409304, 442344020)); + assert_eq!(775672694251729568, func0(1011578373, 2049481248)); + assert_eq!(2062439525931452445, func0(974974257, 2337223277)); + assert_eq!(1604548751928611850, func0(4263530758, 984682115)); + assert_eq!(1177305211198487096, func0(1063015708, 3251055618)); + assert_eq!(4092786701660439636, func0(1871663310, 2897198798)); + assert_eq!(601898756794109321, func0(953677933, 1874629781)); + assert_eq!(7182338930138762251, func0(2171635965, 3332266975)); + assert_eq!(6892263101861225161, func0(3129799999, 2215848091)); + assert_eq!(1610879334455702892, func0(1752808402, 1722448070)); + assert_eq!(5954098380190959489, func0(3886730673, 3984357169)); + assert_eq!(1372560992868278988, func0(559705683, 2647445124)); + assert_eq!(2152711712927790556, func0(2482179638, 1016054794)); + assert_eq!(1515787389000267590, func0(2222408362, 726886703)); + assert_eq!(189627500764286944, func0(172005979, 1207000992)); + assert_eq!(4215965669892889695, func0(2346241635, 1935250581)); + assert_eq!(430287207034939114, func0(407571253, 1810727554)); + assert_eq!(1597374713353464392, func0(3729850776, 806227895)); + assert_eq!(1880883457279792240, func0(636980431, 3440218512)); + assert_eq!(19222848170558640, func0(490631236, 116338668)); + assert_eq!(6794589931404934436, func0(3433275655, 3658451724)); + assert_eq!(2437006998208884613, func0(2549287105, 1225503813)); + assert_eq!(836725431393993716, func0(1351722692, 667251213)); + assert_eq!(778971418295057182, func0(2002949919, 973255522)); + assert_eq!(1824537749281412064, func0(777323632, 3780285522)); + assert_eq!(4194917442664844516, func0(3938911532, 1101896703)); + assert_eq!(4594741650119219018, func0(1090257110, 4267525579)); + assert_eq!(2581741321352371963, func0(1367437265, 2784104459)); + assert_eq!(3957829679827338684, func0(4233798023, 1517104100)); + assert_eq!(756845859427052899, func0(504492337, 4088732467)); + assert_eq!(2918282873851881258, func0(2121232373, 4061750210)); + assert_eq!(3654504162672880726, func0(1789347819, 2526872194)); + assert_eq!(2212868445855255812, func0(4150945879, 551586860)); + assert_eq!(3103486486350451421, func0(2066571807, 4084249991)); + assert_eq!(8607273441719426679, func0(2282233179, 3773178821)); + assert_eq!(1156509613521658418, func0(709954394, 2745522693)); + assert_eq!(252077335585159584, func0(189518072, 2094109404)); + assert_eq!(5062083683181171394, func0(3962498385, 3751106146)); + assert_eq!(3010273305490828905, func0(1227337335, 3019767955)); + assert_eq!(574655313858769572, func0(647047805, 1006590612)); + assert_eq!(4569600963837430108, func0(1334926012, 3949705865)); + assert_eq!(2735819427681789776, func0(1204260345, 2571143888)); + assert_eq!(3974865897512847200, func0(1188267424, 3594501727)); + assert_eq!(7310653617202749736, func0(3752244696, 2586733723)); + assert_eq!(2180000542698929556, func0(2282816124, 1064390863)); + assert_eq!(757270560660105761, func0(4098734879, 518883587)); + assert_eq!(1397504678043332472, func0(3680025976, 1007719105)); + assert_eq!(201012468274968121, func0(500330171, 1049640015)); + assert_eq!(1643195608657045224, func0(1211401672, 1361787525)); + assert_eq!(1438226678867312887, func0(582596071, 2487536817)); + assert_eq!(1626403113695771767, func0(1682129547, 1758180149)); + assert_eq!(4967375577310524888, func0(3217776478, 3155765748)); + assert_eq!(1021827422708145586, func0(3455753262, 383685155)); + assert_eq!(1620087579293700270, func0(1436282169, 1333572990)); + assert_eq!(5439846019754306240, func0(2639863084, 2315606544)); + assert_eq!(3676992219044753402, func0(1202592450, 3298529821)); + assert_eq!(295088102467792584, func0(2640416745, 164556168)); + assert_eq!(420015236428626942, func0(1563437339, 270019450)); + assert_eq!(4171570731399781654, func0(1182897686, 4023304321)); + assert_eq!(313930817850152872, func0(3181491466, 197323460)); + assert_eq!(2120144195882588856, func0(3565200957, 729448088)); + assert_eq!(4135138222079530544, func0(2025811824, 2673130909)); + assert_eq!(974728633115924378, func0(1856250370, 565409485)); + assert_eq!(7012021215195861444, func0(2941085754, 4118018426)); + assert_eq!(4588099163818648368, func0(1386294518, 3420932040)); + assert_eq!(8088587275526614880, func0(3032369406, 3434123472)); + assert_eq!(1777061508699445812, func0(2558922366, 884720302)); + assert_eq!(2852489885718700872, func0(3616495155, 2083420856)); + assert_eq!(6039862574505537392, func0(2152668650, 2818357848)); + assert_eq!(2012276748606470592, func0(612330075, 3333688640)); + assert_eq!(4826579945688757288, func0(4076191460, 3387325242)); + assert_eq!(2954762755339698144, func0(2241130016, 1350138927)); + assert_eq!(6281724276907374272, func0(3617096354, 3729266016)); + assert_eq!(3009040870412314168, func0(2003113772, 3875979722)); + assert_eq!(115984953714082292, func0(103828654, 1204044126)); + assert_eq!(1201962710671725270, func0(1502623546, 1599217823)); + assert_eq!(1768363152935762540, func0(671397894, 4210238226)); + assert_eq!(3356298063062783748, func0(3441635541, 1874361620)); + assert_eq!(191715993548523838, func0(432977822, 814281457)); + assert_eq!(6952761006361384478, func0(2897292062, 4122385281)); + assert_eq!(8791194092176411538, func0(2565668835, 3859055694)); + assert_eq!(444859417520974296, func0(459423377, 1262456920)); + assert_eq!(58842996590135436, func0(2325120661, 29264828)); + assert_eq!(1690509597531888352, func0(832106592, 3557011149)); + assert_eq!(3738965538328709322, func0(1376307282, 4116775085)); + assert_eq!(3226502809094447705, func0(1217804729, 2795769569)); + assert_eq!(599870617048294504, func0(1881778757, 924486472)); + assert_eq!(356346683979125708, func0(2800565998, 189463130)); + assert_eq!(339452588688686662, func0(3963108683, 213057330)); + assert_eq!(3137989196724614390, func0(1929097589, 3765384686)); + assert_eq!(413131240504769782, func0(815413578, 908041479)); + assert_eq!(1984222194355718168, func0(4068422040, 780383249)); + assert_eq!(8449006204868051540, func0(3477426044, 3122989471)); + assert_eq!(1003523456326983103, func0(2835039971, 491446709)); + assert_eq!(245177496324409516, func0(1193399302, 219615282)); + assert_eq!(6726709819786389969, func0(3343756681, 3572602009)); + assert_eq!(2129695280915727138, func0(3488392722, 797874265)); + assert_eq!(3711490030387662669, func0(1472834911, 4195298423)); + assert_eq!(2305461512415025554, func0(4116815943, 601761798)); + assert_eq!(1022204836156138048, func0(1383962014, 875871584)); + assert_eq!(6124058566554237137, func0(4026455285, 3995080245)); + assert_eq!(1743522333418554499, func0(1748966301, 1311047063)); + assert_eq!(3828807313491477561, func0(3109604251, 2105581295)); + assert_eq!(6879005257989111578, func0(3466294670, 3687327535)); + assert_eq!(5934422285573512099, func0(3337410757, 3251080607)); + assert_eq!(271632400619818372, func0(2528046633, 121876516)); + assert_eq!(5618458075617706108, func0(2353193135, 2523769668)); + assert_eq!(6032883871238494250, func0(3795834743, 3958843630)); + assert_eq!(4348234047250267664, func0(3329331112, 1382636938)); + assert_eq!(6484124020093919852, func0(3646068676, 3298564363)); + assert_eq!(2162569950879848392, func0(2351508120, 1041802183)); + assert_eq!(1149438359126280378, func0(1593340915, 907279222)); + assert_eq!(4221264735792051800, func0(3473389753, 1567602712)); + assert_eq!(322951549153389311, func0(1848902261, 498627043)); + assert_eq!(2101141419287719338, func0(1937106203, 1149525974)); + assert_eq!(6656628124022890400, func0(3169621577, 2240684704)); + assert_eq!(3865927343168664368, func0(2988653880, 2065372090)); + assert_eq!(3763738094152388512, func0(3941842616, 1349670076)); + assert_eq!(5500238662055357124, func0(3396275652, 3860786625)); + assert_eq!(6051137854919350040, func0(4237055080, 4149691463)); + assert_eq!(8181209536022266231, func0(2922105553, 3697758535)); + assert_eq!(5246041569354373240, func0(3088748393, 2795236536)); + assert_eq!(795539680939686992, func0(660139075, 1434701872)); + assert_eq!(4310391603222254285, func0(1278383903, 4279467703)); + assert_eq!(1356748400436012116, func0(622969790, 2188943934)); + assert_eq!(2862999109564543010, func0(2074366169, 3664002066)); + assert_eq!(8016245604185390044, func0(3938658919, 2833680580)); + assert_eq!(438342136076279696, func0(170664996, 4265799108)); + assert_eq!(511417529224782932, func0(3818108569, 135071924)); + assert_eq!(2594329379751419479, func0(1762016811, 4129238325)); + assert_eq!(166592537077289776, func0(1808881342, 252697000)); + assert_eq!(1844417793911104709, func0(1101557051, 1729092027)); + assert_eq!(2427902568544198179, func0(3276514261, 2086868271)); + assert_eq!(5674302908067269592, func0(3840088572, 3483581978)); + assert_eq!(6098436633657858032, func0(3924213816, 3909043090)); + assert_eq!(8498808094963741067, func0(3640756479, 2815391645)); + assert_eq!(3564628244928381730, func0(1312701182, 3571368499)); + assert_eq!(118440019183248808, func0(105317505, 1231933864)); + assert_eq!(2752380897181354725, func0(2192467037, 1292436377)); + assert_eq!(5318920590358619788, func0(4114099380, 3554377959)); + assert_eq!(1669231363997182072, func0(1032824101, 3987574552)); + assert_eq!(2179232081886795065, func0(907080859, 3083391727)); + assert_eq!(4108623040475691154, func0(2998238671, 1721007446)); + assert_eq!(7919547175547830232, func0(2287146012, 3604055114)); + assert_eq!(1134464629937020271, func0(1082363119, 1048955521)); + assert_eq!(204645315690484142, func0(2239805873, 93118862)); + assert_eq!(2352414531855514652, func0(2524033954, 1265568366)); + assert_eq!(43971730097200738, func0(62947523, 1878762078)); + assert_eq!(5774656200657986464, func0(3327256464, 3323586826)); + assert_eq!(2317851944644201642, func0(3335695027, 2081292550)); + assert_eq!(1410327517683266240, func0(1560002587, 1415285824)); + assert_eq!(2353637492524558322, func0(3830863346, 1858732289)); + assert_eq!(1727916508081186016, func0(1884194576, 2141511406)); + assert_eq!(4545204708067040200, func0(2256338518, 2082339708)); + assert_eq!(1099346732573237091, func0(3492588511, 396506181)); + assert_eq!(4113751652266832971, func0(1964016451, 2293055737)); + assert_eq!(1235532712581488168, func0(1983855406, 1813729692)); + assert_eq!(437969293200789756, func0(1524404398, 470578162)); + assert_eq!(6813520240937145803, func0(3820723415, 4292070597)); + assert_eq!(427683543762119604, func0(2952741726, 157447118)); + assert_eq!(4068006608723057895, func0(3425685375, 1526663337)); + assert_eq!(6235423430617878844, func0(3429980890, 3318616758)); + assert_eq!(1764396741863418496, func0(1875904924, 1255806176)); + assert_eq!(8058874196613276225, func0(2330845361, 3514366961)); + assert_eq!(7670253288968233269, func0(2902298917, 3828438865)); + assert_eq!(7713452682525289398, func0(3450079054, 2478937125)); + assert_eq!(2321762543005257815, func0(3971444723, 1783469149)); + } + + #[test] + fn func1test() { + assert_eq!(-6647913008218121033, func1(3463795518, 1682485247)); + assert_eq!(448858639501164953, func1(960998136, 3442002022)); + assert_eq!(4331216232566681503, func1(351187803, 2185945601)); + assert_eq!(6501943885585729174, func1(3084014163, 912127940)); + assert_eq!(2773586452911195143, func1(3331261599, 832118177)); + assert_eq!(628282543568432452, func1(3183730720, 1526081701)); + assert_eq!(-8142008469661888158, func1(2898354542, 3213600473)); + assert_eq!(2315370810697976640, func1(3620175596, 4229168685)); + assert_eq!(-7362835817632198335, func1(3101298314, 2777662723)); + assert_eq!(1049535453269404908, func1(697606818, 58376940)); + assert_eq!(9099392518634985681, func1(2281253821, 448345156)); + assert_eq!(-6539444416439664472, func1(1944100306, 1005002010)); + assert_eq!(-307009257995376345, func1(1942570708, 3368934703)); + assert_eq!(1062447846124745127, func1(3917100718, 3641676443)); + assert_eq!(417402990515385795, func1(2273104063, 1591049751)); + assert_eq!(4610956232650099465, func1(915009791, 3424846050)); + assert_eq!(4632634587732872395, func1(347267775, 3096301890)); + assert_eq!(8145395893120941012, func1(3292286689, 1839377893)); + assert_eq!(2027385485099641182, func1(450591296, 3078598150)); + assert_eq!(6716486476978567051, func1(2143937553, 3348758988)); + assert_eq!(8198866944461250122, func1(3018854470, 3889192467)); + assert_eq!(-6892937734432467943, func1(1539512006, 2081336392)); + assert_eq!(3330621345914728912, func1(3249005184, 2848346678)); + assert_eq!(2017804432676575258, func1(2813387773, 345588747)); + assert_eq!(-3851243324500536281, func1(1741339163, 1366337508)); + assert_eq!(-8149088389038900258, func1(3726105746, 1592824540)); + assert_eq!(-864025833727753312, func1(944533733, 159392513)); + assert_eq!(3805337247841405538, func1(1736782229, 3675346013)); + assert_eq!(3020134169454795737, func1(1816111867, 1015431153)); + assert_eq!(-7185405562863503364, func1(1228907531, 378580379)); + assert_eq!(5050542971941349005, func1(3569690671, 2362083614)); + assert_eq!(-8738485908025481017, func1(3477213620, 3564168958)); + assert_eq!(305026462605588943, func1(3774252425, 2324069875)); + assert_eq!(7389524862532086589, func1(4025895326, 3447594450)); + assert_eq!(5501000178805554808, func1(2566538462, 3057776716)); + assert_eq!(5443709636142862360, func1(3467975414, 1642971290)); + assert_eq!(-5647699294804073663, func1(395172703, 2859831371)); + assert_eq!(-3790155150483676964, func1(3285326579, 1892500115)); + assert_eq!(8008118761937744849, func1(800637690, 3507769133)); + assert_eq!(-6322587067393085875, func1(597363944, 4199822201)); + assert_eq!(-399724376400750698, func1(1364679108, 493190167)); + assert_eq!(-7875577358517164187, func1(2930362386, 2610687963)); + assert_eq!(1994499305336764829, func1(3567828522, 84275490)); + assert_eq!(7418908198762244633, func1(1037230963, 2717520219)); + assert_eq!(5452796367047227709, func1(2675210197, 1275728616)); + assert_eq!(-2972964860461358140, func1(2514441382, 3332966386)); + assert_eq!(-2649746958075508610, func1(2369700278, 3199619927)); + assert_eq!(-7044186616817622588, func1(3367457877, 3230470763)); + assert_eq!(6835536980872862161, func1(1306487569, 3253890516)); + assert_eq!(-6979008849175329004, func1(3943542341, 1681756425)); + assert_eq!(1475101851310807018, func1(2498152871, 2876706900)); + assert_eq!(-266749111300060042, func1(1782315350, 3779560764)); + assert_eq!(992376868483489270, func1(208687741, 3099564482)); + assert_eq!(7496704662186028550, func1(4286428893, 1762584453)); + assert_eq!(3048486413080026187, func1(4220403443, 1302445672)); + assert_eq!(2697521928737745324, func1(3700790948, 1404603133)); + assert_eq!(3776917783462454246, func1(3418006820, 4205067295)); + assert_eq!(7925713370373496634, func1(2634361755, 2433583492)); + assert_eq!(-8175129626831597457, func1(1221220233, 1666949297)); + assert_eq!(885713519205033657, func1(1411971418, 1568422082)); + assert_eq!(-6745855444148185973, func1(941730219, 105589570)); + assert_eq!(-3559579113795921176, func1(137958355, 1591971824)); + assert_eq!(1167079093766082498, func1(1872134170, 427167400)); + assert_eq!(-4493134586654147298, func1(3187215651, 4176473865)); + assert_eq!(-7754702505310392891, func1(3614611815, 1836680903)); + assert_eq!(-6983649044183420042, func1(1701800384, 1448715840)); + assert_eq!(4547087054263210229, func1(3552467688, 2656183881)); + assert_eq!(5377035043274396886, func1(2380145620, 154837088)); + assert_eq!(-3862255756903585597, func1(3768076343, 3890514226)); + assert_eq!(-2435510004844691182, func1(702062132, 4202662539)); + assert_eq!(9220688519894226035, func1(3898276141, 947574382)); + assert_eq!(-3949690898565418371, func1(3963535759, 3409647466)); + assert_eq!(-714504777673817158, func1(2791478715, 904408856)); + assert_eq!(2503452673785104063, func1(4004260463, 1275381366)); + assert_eq!(-3193509090430630583, func1(2779315586, 2488033918)); + } +} \ No newline at end of file