default Order dec

$include <exception_basic.sail>
$include <flow.sail>
$include <vector_dec.sail>
$include <arith.sail>

function main (() : unit) -> unit = {
  assert(mult_int(0, 11) == 0);
  assert(mult_int(0, 112) == 0);
  assert(mult_int(0, 1120) == 0);
  assert(mult_int(0, 12) == 0);
  assert(mult_int(0, 2384) == 0);
  assert(mult_int(0, 24) == 0);
  assert(mult_int(0, 24576) == 0);
  assert(mult_int(0, 28) == 0);
  assert(mult_int(0, 280) == 0);
  assert(mult_int(0, 3) == 0);
  assert(mult_int(0, 48) == 0);
  assert(mult_int(0, 49152) == 0);
  assert(mult_int(0, 56) == 0);
  assert(mult_int(0, 560) == 0);
  assert(mult_int(0, 6) == 0);
  assert(mult_int(0, 640) == 0);
  assert(mult_int(0, 664) == 0);
  assert(mult_int(0, 672) == 0);
  assert(mult_int(1, 102850560) == 102850560);
  assert(mult_int(1, 102850561) == 102850561);
  assert(mult_int(1, 102850562) == 102850562);
  assert(mult_int(1, 102850563) == 102850563);
  assert(mult_int(1, 102850564) == 102850564);
  assert(mult_int(1, 102850565) == 102850565);
  assert(mult_int(1, 102850566) == 102850566);
  assert(mult_int(1, 102850567) == 102850567);
  assert(mult_int(1, 102850568) == 102850568);
  assert(mult_int(1, 102850569) == 102850569);
  assert(mult_int(1, 102850570) == 102850570);
  assert(mult_int(1, 102850571) == 102850571);
  assert(mult_int(1, 102850572) == 102850572);
  assert(mult_int(1, 102850573) == 102850573);
  assert(mult_int(1, 102850574) == 102850574);
  assert(mult_int(1, 102850575) == 102850575);
  assert(mult_int(1, 102850608) == 102850608);
  assert(mult_int(1, 102850609) == 102850609);
  assert(mult_int(1, 102850610) == 102850610);
  assert(mult_int(1, 102850611) == 102850611);
  assert(mult_int(1, 102850612) == 102850612);
  assert(mult_int(1, 102850613) == 102850613);
  assert(mult_int(1, 11) == 11);
  assert(mult_int(1, 123052) == 123052);
  assert(mult_int(1, 123053) == 123053);
  assert(mult_int(1, 123054) == 123054);
  assert(mult_int(1, 123055) == 123055);
  assert(mult_int(1, 123056) == 123056);
  assert(mult_int(1, 123057) == 123057);
  assert(mult_int(1, 123058) == 123058);
  assert(mult_int(1, 123059) == 123059);
  assert(mult_int(1, 123060) == 123060);
  assert(mult_int(1, 123119) == 123119);
  assert(mult_int(1, 123120) == 123120);
  assert(mult_int(1, 123121) == 123121);
  assert(mult_int(1, 123122) == 123122);
  assert(mult_int(1, 123123) == 123123);
  assert(mult_int(1, 123124) == 123124);
  assert(mult_int(1, 123125) == 123125);
  assert(mult_int(1, 123126) == 123126);
  assert(mult_int(1, 123127) == 123127);
  assert(mult_int(1, 123128) == 123128);
  assert(mult_int(1, 123129) == 123129);
  assert(mult_int(1, 123130) == 123130);
  assert(mult_int(1, 123131) == 123131);
  assert(mult_int(1, 123132) == 123132);
  assert(mult_int(1, 123133) == 123133);
  assert(mult_int(1, 123134) == 123134);
  assert(mult_int(1, 123135) == 123135);
  assert(mult_int(1, 123136) == 123136);
  assert(mult_int(1, 123137) == 123137);
  assert(mult_int(1, 123138) == 123138);
  assert(mult_int(1, 123139) == 123139);
  assert(mult_int(1, 123140) == 123140);
  assert(mult_int(1, 123141) == 123141);
  assert(mult_int(1, 123142) == 123142);
  assert(mult_int(1, 123143) == 123143);
  assert(mult_int(1, 123144) == 123144);
  assert(mult_int(1, 123145) == 123145);
  assert(mult_int(1, 123146) == 123146);
  assert(mult_int(1, 123147) == 123147);
  assert(mult_int(1, 123148) == 123148);
  assert(mult_int(1, 123149) == 123149);
  assert(mult_int(1, 123150) == 123150);
  assert(mult_int(1, 123151) == 123151);
  assert(mult_int(1, 123152) == 123152);
  assert(mult_int(1, 123153) == 123153);
  assert(mult_int(1, 123154) == 123154);
  assert(mult_int(1, 123155) == 123155);
  assert(mult_int(1, 123156) == 123156);
  assert(mult_int(1, 123157) == 123157);
  assert(mult_int(1, 123158) == 123158);
  assert(mult_int(1, 123159) == 123159);
  assert(mult_int(1, 123160) == 123160);
  assert(mult_int(1, 123161) == 123161);
  assert(mult_int(1, 123162) == 123162);
  assert(mult_int(1, 123163) == 123163);
  assert(mult_int(1, 123164) == 123164);
  assert(mult_int(1, 123165) == 123165);
  assert(mult_int(1, 123166) == 123166);
  assert(mult_int(1, 123200) == 123200);
  assert(mult_int(1, 123201) == 123201);
  assert(mult_int(1, 123202) == 123202);
  assert(mult_int(1, 123203) == 123203);
  assert(mult_int(1, 123204) == 123204);
  assert(mult_int(1, 123205) == 123205);
  assert(mult_int(1, 123206) == 123206);
  assert(mult_int(1, 123207) == 123207);
  assert(mult_int(1, 123208) == 123208);
  assert(mult_int(1, 123209) == 123209);
  assert(mult_int(1, 123210) == 123210);
  assert(mult_int(1, 123211) == 123211);
  assert(mult_int(1, 123212) == 123212);
  assert(mult_int(1, 123213) == 123213);
  assert(mult_int(1, 123214) == 123214);
  assert(mult_int(1, 123215) == 123215);
  assert(mult_int(1, 123216) == 123216);
  assert(mult_int(1, 123217) == 123217);
  assert(mult_int(1, 123218) == 123218);
  assert(mult_int(1, 123219) == 123219);
  assert(mult_int(1, 123220) == 123220);
  assert(mult_int(1, 123221) == 123221);
  assert(mult_int(1, 123222) == 123222);
  assert(mult_int(1, 123223) == 123223);
  assert(mult_int(1, 123224) == 123224);
  assert(mult_int(1, 123225) == 123225);
  assert(mult_int(1, 123226) == 123226);
  assert(mult_int(1, 123227) == 123227);
  assert(mult_int(1, 123228) == 123228);
  assert(mult_int(1, 123288) == 123288);
  assert(mult_int(1, 123289) == 123289);
  assert(mult_int(1, 123290) == 123290);
  assert(mult_int(1, 123291) == 123291);
  assert(mult_int(1, 123292) == 123292);
  assert(mult_int(1, 123293) == 123293);
  assert(mult_int(1, 123294) == 123294);
  assert(mult_int(1, 123295) == 123295);
  assert(mult_int(1, 123296) == 123296);
  assert(mult_int(1, 123297) == 123297);
  assert(mult_int(1, 123298) == 123298);
  assert(mult_int(1, 123299) == 123299);
  assert(mult_int(1, 123300) == 123300);
  assert(mult_int(1, 123301) == 123301);
  assert(mult_int(1, 123302) == 123302);
  assert(mult_int(1, 123303) == 123303);
  assert(mult_int(1, 123304) == 123304);
  assert(mult_int(1, 123305) == 123305);
  assert(mult_int(1, 123306) == 123306);
  assert(mult_int(1, 123307) == 123307);
  assert(mult_int(1, 123308) == 123308);
  assert(mult_int(1, 123309) == 123309);
  assert(mult_int(1, 123310) == 123310);
  assert(mult_int(1, 123311) == 123311);
  assert(mult_int(1, 123312) == 123312);
  assert(mult_int(1, 125988) == 125988);
  assert(mult_int(1, 125989) == 125989);
  assert(mult_int(1, 125990) == 125990);
  assert(mult_int(1, 125991) == 125991);
  assert(mult_int(1, 125992) == 125992);
  assert(mult_int(1, 125993) == 125993);
  assert(mult_int(1, 125994) == 125994);
  assert(mult_int(1, 125995) == 125995);
  assert(mult_int(1, 125996) == 125996);
  assert(mult_int(1, 125997) == 125997);
  assert(mult_int(1, 125998) == 125998);
  assert(mult_int(1, 125999) == 125999);
  assert(mult_int(1, 126000) == 126000);
  assert(mult_int(1, 126001) == 126001);
  assert(mult_int(1, 126002) == 126002);
  assert(mult_int(1, 126003) == 126003);
  assert(mult_int(1, 126004) == 126004);
  assert(mult_int(1, 126005) == 126005);
  assert(mult_int(1, 126006) == 126006);
  assert(mult_int(1, 126007) == 126007);
  assert(mult_int(1, 126008) == 126008);
  assert(mult_int(1, 126009) == 126009);
  assert(mult_int(1, 126010) == 126010);
  assert(mult_int(1, 126076) == 126076);
  assert(mult_int(1, 126077) == 126077);
  assert(mult_int(1, 126078) == 126078);
  assert(mult_int(1, 126079) == 126079);
  assert(mult_int(1, 126080) == 126080);
  assert(mult_int(1, 126081) == 126081);
  assert(mult_int(1, 126082) == 126082);
  assert(mult_int(1, 126083) == 126083);
  assert(mult_int(1, 126084) == 126084);
  assert(mult_int(1, 126085) == 126085);
  assert(mult_int(1, 126086) == 126086);
  assert(mult_int(1, 126087) == 126087);
  assert(mult_int(1, 126088) == 126088);
  assert(mult_int(1, 126089) == 126089);
  assert(mult_int(1, 126090) == 126090);
  assert(mult_int(1, 126091) == 126091);
  assert(mult_int(1, 126092) == 126092);
  assert(mult_int(1, 126093) == 126093);
  assert(mult_int(1, 126094) == 126094);
  assert(mult_int(1, 126095) == 126095);
  assert(mult_int(1, 126096) == 126096);
  assert(mult_int(1, 126097) == 126097);
  assert(mult_int(1, 126098) == 126098);
  assert(mult_int(1, 137040) == 137040);
  assert(mult_int(1, 137041) == 137041);
  assert(mult_int(1, 137042) == 137042);
  assert(mult_int(1, 137043) == 137043);
  assert(mult_int(1, 137044) == 137044);
  assert(mult_int(1, 137045) == 137045);
  assert(mult_int(1, 137046) == 137046);
  assert(mult_int(1, 137047) == 137047);
  assert(mult_int(1, 137048) == 137048);
  assert(mult_int(1, 137049) == 137049);
  assert(mult_int(1, 137050) == 137050);
  assert(mult_int(1, 137051) == 137051);
  assert(mult_int(1, 137052) == 137052);
  assert(mult_int(1, 137053) == 137053);
  assert(mult_int(1, 137054) == 137054);
  assert(mult_int(1, 137055) == 137055);
  assert(mult_int(1, 137056) == 137056);
  assert(mult_int(1, 137057) == 137057);
  assert(mult_int(1, 137060) == 137060);
  assert(mult_int(1, 137061) == 137061);
  assert(mult_int(1, 137062) == 137062);
  assert(mult_int(1, 137063) == 137063);
  assert(mult_int(1, 137064) == 137064);
  assert(mult_int(1, 137065) == 137065);
  assert(mult_int(1, 137066) == 137066);
  assert(mult_int(1, 137128) == 137128);
  assert(mult_int(1, 137129) == 137129);
  assert(mult_int(1, 137130) == 137130);
  assert(mult_int(1, 137131) == 137131);
  assert(mult_int(1, 137132) == 137132);
  assert(mult_int(1, 137133) == 137133);
  assert(mult_int(1, 137134) == 137134);
  assert(mult_int(1, 137135) == 137135);
  assert(mult_int(1, 137136) == 137136);
  assert(mult_int(1, 137137) == 137137);
  assert(mult_int(1, 137138) == 137138);
  assert(mult_int(1, 137139) == 137139);
  assert(mult_int(1, 137140) == 137140);
  assert(mult_int(1, 137141) == 137141);
  assert(mult_int(1, 137142) == 137142);
  assert(mult_int(1, 137143) == 137143);
  assert(mult_int(1, 137144) == 137144);
  assert(mult_int(1, 137145) == 137145);
  assert(mult_int(1, 137148) == 137148);
  assert(mult_int(1, 137149) == 137149);
  assert(mult_int(1, 137150) == 137150);
  assert(mult_int(1, 137151) == 137151);
  assert(mult_int(1, 137152) == 137152);
  assert(mult_int(1, 137153) == 137153);
  assert(mult_int(1, 137154) == 137154);
  assert(mult_int(1, 137580) == 137580);
  assert(mult_int(1, 137581) == 137581);
  assert(mult_int(1, 137582) == 137582);
  assert(mult_int(1, 137583) == 137583);
  assert(mult_int(1, 137584) == 137584);
  assert(mult_int(1, 137585) == 137585);
  assert(mult_int(1, 137586) == 137586);
  assert(mult_int(1, 137587) == 137587);
  assert(mult_int(1, 137588) == 137588);
  assert(mult_int(1, 137589) == 137589);
  assert(mult_int(1, 137590) == 137590);
  assert(mult_int(1, 137591) == 137591);
  assert(mult_int(1, 137592) == 137592);
  assert(mult_int(1, 137593) == 137593);
  assert(mult_int(1, 137594) == 137594);
  assert(mult_int(1, 137595) == 137595);
  assert(mult_int(1, 137596) == 137596);
  assert(mult_int(1, 137597) == 137597);
  assert(mult_int(1, 137598) == 137598);
  assert(mult_int(1, 137599) == 137599);
  assert(mult_int(1, 137600) == 137600);
  assert(mult_int(1, 137601) == 137601);
  assert(mult_int(1, 137602) == 137602);
  assert(mult_int(1, 137603) == 137603);
  assert(mult_int(1, 137668) == 137668);
  assert(mult_int(1, 137669) == 137669);
  assert(mult_int(1, 137670) == 137670);
  assert(mult_int(1, 137671) == 137671);
  assert(mult_int(1, 137672) == 137672);
  assert(mult_int(1, 137673) == 137673);
  assert(mult_int(1, 137674) == 137674);
  assert(mult_int(1, 137675) == 137675);
  assert(mult_int(1, 137676) == 137676);
  assert(mult_int(1, 137677) == 137677);
  assert(mult_int(1, 137678) == 137678);
  assert(mult_int(1, 137679) == 137679);
  assert(mult_int(1, 137680) == 137680);
  assert(mult_int(1, 137681) == 137681);
  assert(mult_int(1, 137682) == 137682);
  assert(mult_int(1, 137683) == 137683);
  assert(mult_int(1, 137684) == 137684);
  assert(mult_int(1, 137685) == 137685);
  assert(mult_int(1, 137686) == 137686);
  assert(mult_int(1, 137687) == 137687);
  assert(mult_int(1, 137688) == 137688);
  assert(mult_int(1, 137689) == 137689);
  assert(mult_int(1, 137690) == 137690);
  assert(mult_int(1, 137691) == 137691);
  assert(mult_int(1, 137872) == 137872);
  assert(mult_int(1, 137873) == 137873);
  assert(mult_int(1, 137874) == 137874);
  assert(mult_int(1, 137875) == 137875);
  assert(mult_int(1, 137876) == 137876);
  assert(mult_int(1, 137877) == 137877);
  assert(mult_int(1, 137878) == 137878);
  assert(mult_int(1, 137879) == 137879);
  assert(mult_int(1, 137880) == 137880);
  assert(mult_int(1, 137881) == 137881);
  assert(mult_int(1, 137882) == 137882);
  assert(mult_int(1, 137883) == 137883);
  assert(mult_int(1, 137884) == 137884);
  assert(mult_int(1, 137885) == 137885);
  assert(mult_int(1, 137886) == 137886);
  assert(mult_int(1, 137887) == 137887);
  assert(mult_int(1, 137888) == 137888);
  assert(mult_int(1, 137889) == 137889);
  assert(mult_int(1, 137890) == 137890);
  assert(mult_int(1, 137891) == 137891);
  assert(mult_int(1, 137892) == 137892);
  assert(mult_int(1, 137893) == 137893);
  assert(mult_int(1, 137894) == 137894);
  assert(mult_int(1, 137895) == 137895);
  assert(mult_int(1, 137896) == 137896);
  assert(mult_int(1, 137897) == 137897);
  assert(mult_int(1, 137898) == 137898);
  assert(mult_int(1, 137960) == 137960);
  assert(mult_int(1, 137961) == 137961);
  assert(mult_int(1, 137962) == 137962);
  assert(mult_int(1, 137963) == 137963);
  assert(mult_int(1, 137964) == 137964);
  assert(mult_int(1, 137965) == 137965);
  assert(mult_int(1, 137966) == 137966);
  assert(mult_int(1, 137967) == 137967);
  assert(mult_int(1, 137968) == 137968);
  assert(mult_int(1, 137969) == 137969);
  assert(mult_int(1, 137970) == 137970);
  assert(mult_int(1, 137971) == 137971);
  assert(mult_int(1, 137972) == 137972);
  assert(mult_int(1, 137973) == 137973);
  assert(mult_int(1, 137974) == 137974);
  assert(mult_int(1, 137975) == 137975);
  assert(mult_int(1, 137976) == 137976);
  assert(mult_int(1, 137977) == 137977);
  assert(mult_int(1, 137978) == 137978);
  assert(mult_int(1, 137979) == 137979);
  assert(mult_int(1, 137980) == 137980);
  assert(mult_int(1, 137981) == 137981);
  assert(mult_int(1, 137982) == 137982);
  assert(mult_int(1, 137983) == 137983);
  assert(mult_int(1, 137984) == 137984);
  assert(mult_int(1, 137985) == 137985);
  assert(mult_int(1, 137986) == 137986);
  assert(mult_int(1, 138504) == 138504);
  assert(mult_int(1, 138505) == 138505);
  assert(mult_int(1, 138506) == 138506);
  assert(mult_int(1, 138507) == 138507);
  assert(mult_int(1, 138508) == 138508);
  assert(mult_int(1, 138509) == 138509);
  assert(mult_int(1, 138510) == 138510);
  assert(mult_int(1, 138511) == 138511);
  assert(mult_int(1, 138512) == 138512);
  assert(mult_int(1, 138513) == 138513);
  assert(mult_int(1, 138516) == 138516);
  assert(mult_int(1, 138517) == 138517);
  assert(mult_int(1, 138518) == 138518);
  assert(mult_int(1, 138519) == 138519);
  assert(mult_int(1, 138520) == 138520);
  assert(mult_int(1, 138521) == 138521);
  assert(mult_int(1, 138522) == 138522);
  assert(mult_int(1, 138523) == 138523);
  assert(mult_int(1, 138524) == 138524);
  assert(mult_int(1, 138525) == 138525);
  assert(mult_int(1, 138526) == 138526);
  assert(mult_int(1, 138527) == 138527);
  assert(mult_int(1, 138528) == 138528);
  assert(mult_int(1, 138529) == 138529);
  assert(mult_int(1, 138530) == 138530);
  assert(mult_int(1, 138531) == 138531);
  assert(mult_int(1, 138532) == 138532);
  assert(mult_int(1, 138533) == 138533);
  assert(mult_int(1, 138534) == 138534);
  assert(mult_int(1, 138535) == 138535);
  assert(mult_int(1, 138536) == 138536);
  assert(mult_int(1, 138537) == 138537);
  assert(mult_int(1, 138538) == 138538);
  assert(mult_int(1, 138539) == 138539);
  assert(mult_int(1, 138540) == 138540);
  assert(mult_int(1, 138541) == 138541);
  assert(mult_int(1, 138544) == 138544);
  assert(mult_int(1, 138545) == 138545);
  assert(mult_int(1, 138546) == 138546);
  assert(mult_int(1, 138547) == 138547);
  assert(mult_int(1, 138548) == 138548);
  assert(mult_int(1, 138549) == 138549);
  assert(mult_int(1, 138550) == 138550);
  assert(mult_int(1, 138551) == 138551);
  assert(mult_int(1, 138552) == 138552);
  assert(mult_int(1, 138553) == 138553);
  assert(mult_int(1, 138556) == 138556);
  assert(mult_int(1, 138557) == 138557);
  assert(mult_int(1, 138558) == 138558);
  assert(mult_int(1, 138559) == 138559);
  assert(mult_int(1, 138560) == 138560);
  assert(mult_int(1, 138561) == 138561);
  assert(mult_int(1, 138562) == 138562);
  assert(mult_int(1, 138563) == 138563);
  assert(mult_int(1, 138564) == 138564);
  assert(mult_int(1, 138565) == 138565);
  assert(mult_int(1, 138568) == 138568);
  assert(mult_int(1, 138569) == 138569);
  assert(mult_int(1, 138570) == 138570);
  assert(mult_int(1, 138571) == 138571);
  assert(mult_int(1, 138572) == 138572);
  assert(mult_int(1, 138573) == 138573);
  assert(mult_int(1, 138574) == 138574);
  assert(mult_int(1, 138575) == 138575);
  assert(mult_int(1, 138576) == 138576);
  assert(mult_int(1, 138577) == 138577);
  assert(mult_int(1, 138580) == 138580);
  assert(mult_int(1, 138581) == 138581);
  assert(mult_int(1, 138582) == 138582);
  assert(mult_int(1, 138583) == 138583);
  assert(mult_int(1, 138584) == 138584);
  assert(mult_int(1, 138585) == 138585);
  assert(mult_int(1, 138586) == 138586);
  assert(mult_int(1, 138587) == 138587);
  assert(mult_int(1, 138588) == 138588);
  assert(mult_int(1, 138589) == 138589);
  assert(mult_int(1, 138592) == 138592);
  assert(mult_int(1, 138593) == 138593);
  assert(mult_int(1, 138594) == 138594);
  assert(mult_int(1, 138595) == 138595);
  assert(mult_int(1, 138596) == 138596);
  assert(mult_int(1, 138597) == 138597);
  assert(mult_int(1, 138598) == 138598);
  assert(mult_int(1, 138599) == 138599);
  assert(mult_int(1, 138600) == 138600);
  assert(mult_int(1, 138601) == 138601);
  assert(mult_int(1, 138604) == 138604);
  assert(mult_int(1, 138605) == 138605);
  assert(mult_int(1, 138606) == 138606);
  assert(mult_int(1, 138607) == 138607);
  assert(mult_int(1, 138608) == 138608);
  assert(mult_int(1, 138609) == 138609);
  assert(mult_int(1, 138610) == 138610);
  assert(mult_int(1, 138611) == 138611);
  assert(mult_int(1, 138612) == 138612);
  assert(mult_int(1, 138613) == 138613);
  assert(mult_int(1, 138614) == 138614);
  assert(mult_int(1, 138615) == 138615);
  assert(mult_int(1, 138616) == 138616);
  assert(mult_int(1, 138617) == 138617);
  assert(mult_int(1, 138618) == 138618);
  assert(mult_int(1, 138619) == 138619);
  assert(mult_int(1, 138620) == 138620);
  assert(mult_int(1, 138621) == 138621);
  assert(mult_int(1, 138622) == 138622);
  assert(mult_int(1, 138623) == 138623);
  assert(mult_int(1, 138624) == 138624);
  assert(mult_int(1, 138625) == 138625);
  assert(mult_int(1, 138626) == 138626);
  assert(mult_int(1, 138627) == 138627);
  assert(mult_int(1, 138628) == 138628);
  assert(mult_int(1, 138629) == 138629);
  assert(mult_int(1, 138632) == 138632);
  assert(mult_int(1, 138633) == 138633);
  assert(mult_int(1, 138634) == 138634);
  assert(mult_int(1, 138635) == 138635);
  assert(mult_int(1, 138636) == 138636);
  assert(mult_int(1, 138637) == 138637);
  assert(mult_int(1, 138638) == 138638);
  assert(mult_int(1, 138639) == 138639);
  assert(mult_int(1, 138640) == 138640);
  assert(mult_int(1, 138641) == 138641);
  assert(mult_int(1, 138644) == 138644);
  assert(mult_int(1, 138645) == 138645);
  assert(mult_int(1, 138646) == 138646);
  assert(mult_int(1, 138647) == 138647);
  assert(mult_int(1, 138648) == 138648);
  assert(mult_int(1, 138649) == 138649);
  assert(mult_int(1, 138650) == 138650);
  assert(mult_int(1, 138651) == 138651);
  assert(mult_int(1, 138652) == 138652);
  assert(mult_int(1, 138653) == 138653);
  assert(mult_int(1, 138656) == 138656);
  assert(mult_int(1, 138657) == 138657);
  assert(mult_int(1, 138658) == 138658);
  assert(mult_int(1, 138659) == 138659);
  assert(mult_int(1, 138660) == 138660);
  assert(mult_int(1, 138661) == 138661);
  assert(mult_int(1, 138662) == 138662);
  assert(mult_int(1, 138663) == 138663);
  assert(mult_int(1, 138664) == 138664);
  assert(mult_int(1, 138665) == 138665);
  assert(mult_int(1, 138668) == 138668);
  assert(mult_int(1, 138669) == 138669);
  assert(mult_int(1, 138670) == 138670);
  assert(mult_int(1, 138671) == 138671);
  assert(mult_int(1, 138672) == 138672);
  assert(mult_int(1, 138673) == 138673);
  assert(mult_int(1, 138674) == 138674);
  assert(mult_int(1, 138675) == 138675);
  assert(mult_int(1, 138676) == 138676);
  assert(mult_int(1, 138677) == 138677);
  assert(mult_int(1, 144864) == 144864);
  assert(mult_int(1, 144865) == 144865);
  assert(mult_int(1, 144866) == 144866);
  assert(mult_int(1, 144867) == 144867);
  assert(mult_int(1, 144868) == 144868);
  assert(mult_int(1, 144869) == 144869);
  assert(mult_int(1, 144870) == 144870);
  assert(mult_int(1, 144871) == 144871);
  assert(mult_int(1, 144872) == 144872);
  assert(mult_int(1, 144873) == 144873);
  assert(mult_int(1, 144874) == 144874);
  assert(mult_int(1, 144875) == 144875);
  assert(mult_int(1, 144876) == 144876);
  assert(mult_int(1, 144877) == 144877);
  assert(mult_int(1, 144878) == 144878);
  assert(mult_int(1, 144879) == 144879);
  assert(mult_int(1, 144880) == 144880);
  assert(mult_int(1, 144881) == 144881);
  assert(mult_int(1, 144882) == 144882);
  assert(mult_int(1, 144883) == 144883);
  assert(mult_int(1, 144884) == 144884);
  assert(mult_int(1, 144885) == 144885);
  assert(mult_int(1, 144886) == 144886);
  assert(mult_int(1, 144887) == 144887);
  assert(mult_int(1, 144888) == 144888);
  assert(mult_int(1, 144952) == 144952);
  assert(mult_int(1, 144953) == 144953);
  assert(mult_int(1, 144954) == 144954);
  assert(mult_int(1, 144955) == 144955);
  assert(mult_int(1, 144956) == 144956);
  assert(mult_int(1, 144957) == 144957);
  assert(mult_int(1, 144958) == 144958);
  assert(mult_int(1, 144959) == 144959);
  assert(mult_int(1, 144960) == 144960);
  assert(mult_int(1, 144961) == 144961);
  assert(mult_int(1, 144962) == 144962);
  assert(mult_int(1, 144963) == 144963);
  assert(mult_int(1, 144964) == 144964);
  assert(mult_int(1, 144965) == 144965);
  assert(mult_int(1, 144966) == 144966);
  assert(mult_int(1, 144967) == 144967);
  assert(mult_int(1, 144968) == 144968);
  assert(mult_int(1, 144969) == 144969);
  assert(mult_int(1, 144970) == 144970);
  assert(mult_int(1, 144971) == 144971);
  assert(mult_int(1, 144972) == 144972);
  assert(mult_int(1, 144973) == 144973);
  assert(mult_int(1, 144974) == 144974);
  assert(mult_int(1, 144975) == 144975);
  assert(mult_int(1, 144976) == 144976);
  assert(mult_int(1, 20971524) == 20971524);
  assert(mult_int(1, 20971525) == 20971525);
  assert(mult_int(1, 20971526) == 20971526);
  assert(mult_int(1, 20971527) == 20971527);
  assert(mult_int(1, 20971528) == 20971528);
  assert(mult_int(1, 20971529) == 20971529);
  assert(mult_int(1, 20971530) == 20971530);
  assert(mult_int(1, 20971531) == 20971531);
  assert(mult_int(1, 20971532) == 20971532);
  assert(mult_int(1, 20971533) == 20971533);
  assert(mult_int(1, 20971534) == 20971534);
  assert(mult_int(1, 20971535) == 20971535);
  assert(mult_int(1, 20971536) == 20971536);
  assert(mult_int(1, 20971537) == 20971537);
  assert(mult_int(1, 3145728) == 3145728);
  assert(mult_int(1, 3145729) == 3145729);
  assert(mult_int(1, 3145730) == 3145730);
  assert(mult_int(1, 3145731) == 3145731);
  assert(mult_int(1, 3145732) == 3145732);
  assert(mult_int(1, 3145733) == 3145733);
  assert(mult_int(1, 3145734) == 3145734);
  assert(mult_int(1, 3145735) == 3145735);
  assert(mult_int(1, 3145736) == 3145736);
  assert(mult_int(1, 3145737) == 3145737);
  assert(mult_int(1, 3145738) == 3145738);
  assert(mult_int(1, 3145739) == 3145739);
  assert(mult_int(1, 3145740) == 3145740);
  assert(mult_int(1, 3145741) == 3145741);
  assert(mult_int(1, 3145742) == 3145742);
  assert(mult_int(1, 318767104) == 318767104);
  assert(mult_int(1, 50367776) == 50367776);
  assert(mult_int(1, 50367777) == 50367777);
  assert(mult_int(1, 50367824) == 50367824);
  assert(mult_int(1, 50367825) == 50367825);
  assert(mult_int(1, 50367872) == 50367872);
  assert(mult_int(1, 58720273) == 58720273);
  assert(mult_int(1, 58720274) == 58720274);
  assert(mult_int(1, 58720275) == 58720275);
  assert(mult_int(1, 58720315) == 58720315);
  assert(mult_int(1, 58720316) == 58720316);
  assert(mult_int(1, 58720317) == 58720317);
  assert(mult_int(1, 58720332) == 58720332);
  assert(mult_int(1, 58720333) == 58720333);
  assert(mult_int(1, 58720334) == 58720334);
  assert(mult_int(1, 6) == 6);
  assert(mult_int(1, 8) == 8);
  assert(mult_int(10, 0) == 0);
  assert(mult_int(10, 1) == 10);
  assert(mult_int(10, 2) == 20);
  assert(mult_int(10, 3) == 30);
  assert(mult_int(1024, 1) == 1024);
  assert(mult_int(16, 0) == 0);
  assert(mult_int(16, 3147986) == 50367776);
  assert(mult_int(16, 3147988) == 50367808);
  assert(mult_int(16, 3147989) == 50367824);
  assert(mult_int(16, 3147991) == 50367856);
  assert(mult_int(16, 3147992) == 50367872);
  assert(mult_int(16, 3147994) == 50367904);
  assert(mult_int(16, 3147995) == 50367920);
  assert(mult_int(16, 3147998) == 50367968);
  assert(mult_int(16, 3147999) == 50367984);
  assert(mult_int(16, 3148000) == 50368000);
  assert(mult_int(16, 3148001) == 50368016);
  assert(mult_int(16, 3148002) == 50368032);
  assert(mult_int(16, 3670060) == 58720960);
  assert(mult_int(16, 3670065) == 58721040);
  assert(mult_int(16, 3670067) == 58721072);
  assert(mult_int(16, 3670069) == 58721104);
  assert(mult_int(16, 3670070) == 58721120);
  assert(mult_int(16, 3670074) == 58721184);
  assert(mult_int(16, 3670075) == 58721200);
  assert(mult_int(16, 3670077) == 58721232);
  assert(mult_int(16, 3670079) == 58721264);
  assert(mult_int(16, 3670082) == 58721312);
  assert(mult_int(16, 3670083) == 58721328);
  assert(mult_int(16, 3670084) == 58721344);
  assert(mult_int(16, 3670085) == 58721360);
  assert(mult_int(16, 3670086) == 58721376);
  assert(mult_int(16, 66650) == 1066400);
  assert(mult_int(16, 66652) == 1066432);
  assert(mult_int(16, 66663) == 1066608);
  assert(mult_int(16, 66676) == 1066816);
  assert(mult_int(2, 0) == 0);
  assert(mult_int(2, 11) == 22);
  assert(mult_int(3, 11) == 33);
  assert(mult_int(4, 110624798) == 442499192);
  assert(mult_int(4, 110624799) == 442499196);
  assert(mult_int(4, 110624800) == 442499200);
  assert(mult_int(4, 12582917) == 50331668);
  assert(mult_int(4, 12582918) == 50331672);
  assert(mult_int(4, 12582919) == 50331676);
  assert(mult_int(4, 12582920) == 50331680);
  assert(mult_int(4, 12582924) == 50331696);
  assert(mult_int(4, 12582933) == 50331732);
  assert(mult_int(4, 12582934) == 50331736);
  assert(mult_int(4, 12582938) == 50331752);
  assert(mult_int(4, 12582962) == 50331848);
  assert(mult_int(4, 12589764) == 50359056);
  assert(mult_int(4, 12589765) == 50359060);
  assert(mult_int(4, 12591944) == 50367776);
  assert(mult_int(4, 12591945) == 50367780);
  assert(mult_int(4, 12591946) == 50367784);
  assert(mult_int(4, 12591956) == 50367824);
  assert(mult_int(4, 12591957) == 50367828);
  assert(mult_int(4, 12591958) == 50367832);
  assert(mult_int(4, 12591959) == 50367836);
  assert(mult_int(4, 12591960) == 50367840);
  assert(mult_int(4, 12591961) == 50367844);
  assert(mult_int(4, 12591962) == 50367848);
  assert(mult_int(4, 12591963) == 50367852);
  assert(mult_int(4, 12591964) == 50367856);
  assert(mult_int(4, 12591965) == 50367860);
  assert(mult_int(4, 12591966) == 50367864);
  assert(mult_int(4, 12591967) == 50367868);
  assert(mult_int(4, 12591968) == 50367872);
  assert(mult_int(4, 12591969) == 50367876);
  assert(mult_int(4, 12591970) == 50367880);
  assert(mult_int(4, 12591971) == 50367884);
  assert(mult_int(4, 12591972) == 50367888);
  assert(mult_int(4, 12591973) == 50367892);
  assert(mult_int(4, 12591974) == 50367896);
  assert(mult_int(4, 12591975) == 50367900);
  assert(mult_int(4, 12591976) == 50367904);
  assert(mult_int(4, 12591977) == 50367908);
  assert(mult_int(4, 12591978) == 50367912);
  assert(mult_int(4, 12591979) == 50367916);
  assert(mult_int(4, 12591980) == 50367920);
  assert(mult_int(4, 12591981) == 50367924);
  assert(mult_int(4, 12591982) == 50367928);
  assert(mult_int(4, 12591983) == 50367932);
  assert(mult_int(4, 12591984) == 50367936);
  assert(mult_int(4, 12591985) == 50367940);
  assert(mult_int(4, 12591986) == 50367944);
  assert(mult_int(4, 12591987) == 50367948);
  assert(mult_int(4, 12591988) == 50367952);
  assert(mult_int(4, 12591989) == 50367956);
  assert(mult_int(4, 12591990) == 50367960);
  assert(mult_int(4, 12591991) == 50367964);
  assert(mult_int(4, 12591992) == 50367968);
  assert(mult_int(4, 12591993) == 50367972);
  assert(mult_int(4, 12591994) == 50367976);
  assert(mult_int(4, 12591995) == 50367980);
  assert(mult_int(4, 13058048) == 52232192);
  assert(mult_int(4, 13058049) == 52232196);
  assert(mult_int(4, 13058050) == 52232200);
  assert(mult_int(4, 13058051) == 52232204);
  assert(mult_int(4, 13058052) == 52232208);
  assert(mult_int(4, 13058053) == 52232212);
  assert(mult_int(4, 13058054) == 52232216);
  assert(mult_int(4, 13058055) == 52232220);
  assert(mult_int(4, 13058056) == 52232224);
  assert(mult_int(4, 13058064) == 52232256);
  assert(mult_int(4, 13058065) == 52232260);
  assert(mult_int(4, 13058066) == 52232264);
  assert(mult_int(4, 13058067) == 52232268);
  assert(mult_int(4, 13058068) == 52232272);
  assert(mult_int(4, 13058069) == 52232276);
  assert(mult_int(4, 13058070) == 52232280);
  assert(mult_int(4, 13058071) == 52232284);
  assert(mult_int(4, 13058072) == 52232288);
  assert(mult_int(4, 13058073) == 52232292);
  assert(mult_int(4, 13058074) == 52232296);
  assert(mult_int(4, 13058075) == 52232300);
  assert(mult_int(4, 13058076) == 52232304);
  assert(mult_int(4, 13058077) == 52232308);
  assert(mult_int(4, 13058078) == 52232312);
  assert(mult_int(4, 13058079) == 52232316);
  assert(mult_int(4, 13058080) == 52232320);
  assert(mult_int(4, 13058081) == 52232324);
  assert(mult_int(4, 13058082) == 52232328);
  assert(mult_int(4, 13058083) == 52232332);
  assert(mult_int(4, 13058084) == 52232336);
  assert(mult_int(4, 13058085) == 52232340);
  assert(mult_int(4, 13058086) == 52232344);
  assert(mult_int(4, 13058087) == 52232348);
  assert(mult_int(4, 13058088) == 52232352);
  assert(mult_int(4, 13058089) == 52232356);
  assert(mult_int(4, 13058090) == 52232360);
  assert(mult_int(4, 13058091) == 52232364);
  assert(mult_int(4, 13058092) == 52232368);
  assert(mult_int(4, 13058093) == 52232372);
  assert(mult_int(4, 13058094) == 52232376);
  assert(mult_int(4, 13058095) == 52232380);
  assert(mult_int(4, 13058096) == 52232384);
  assert(mult_int(4, 13058097) == 52232388);
  assert(mult_int(4, 13058098) == 52232392);
  assert(mult_int(4, 13058099) == 52232396);
  assert(mult_int(4, 13058100) == 52232400);
  assert(mult_int(4, 13058101) == 52232404);
  assert(mult_int(4, 13058102) == 52232408);
  assert(mult_int(4, 13058103) == 52232412);
  assert(mult_int(4, 13058104) == 52232416);
  assert(mult_int(4, 13058105) == 52232420);
  assert(mult_int(4, 13058106) == 52232424);
  assert(mult_int(4, 13058107) == 52232428);
  assert(mult_int(4, 13058108) == 52232432);
  assert(mult_int(4, 13058109) == 52232436);
  assert(mult_int(4, 13058110) == 52232440);
  assert(mult_int(4, 13058111) == 52232444);
  assert(mult_int(4, 13058112) == 52232448);
  assert(mult_int(4, 13058113) == 52232452);
  assert(mult_int(4, 13058114) == 52232456);
  assert(mult_int(4, 13058115) == 52232460);
  assert(mult_int(4, 13058116) == 52232464);
  assert(mult_int(4, 13058126) == 52232504);
  assert(mult_int(4, 13058127) == 52232508);
  assert(mult_int(4, 13058128) == 52232512);
  assert(mult_int(4, 13058129) == 52232516);
  assert(mult_int(4, 13058142) == 52232568);
  assert(mult_int(4, 13058143) == 52232572);
  assert(mult_int(4, 13058149) == 52232596);
  assert(mult_int(4, 13058232) == 52232928);
  assert(mult_int(4, 13058356) == 52233424);
  assert(mult_int(4, 13058357) == 52233428);
  assert(mult_int(4, 13058358) == 52233432);
  assert(mult_int(4, 13058359) == 52233436);
  assert(mult_int(4, 13058360) == 52233440);
  assert(mult_int(4, 13058361) == 52233444);
  assert(mult_int(4, 13058362) == 52233448);
  assert(mult_int(4, 13058363) == 52233452);
  assert(mult_int(4, 13058364) == 52233456);
  assert(mult_int(4, 13058365) == 52233460);
  assert(mult_int(4, 13058366) == 52233464);
  assert(mult_int(4, 13058367) == 52233468);
  assert(mult_int(4, 13058368) == 52233472);
  assert(mult_int(4, 13058369) == 52233476);
  assert(mult_int(4, 13058370) == 52233480);
  assert(mult_int(4, 13058371) == 52233484);
  assert(mult_int(4, 13058372) == 52233488);
  assert(mult_int(4, 13058373) == 52233492);
  assert(mult_int(4, 13058374) == 52233496);
  assert(mult_int(4, 13058375) == 52233500);
  assert(mult_int(4, 13058376) == 52233504);
  assert(mult_int(4, 13058377) == 52233508);
  assert(mult_int(4, 13058378) == 52233512);
  assert(mult_int(4, 13058379) == 52233516);
  assert(mult_int(4, 13058380) == 52233520);
  assert(mult_int(4, 13058381) == 52233524);
  assert(mult_int(4, 13058382) == 52233528);
  assert(mult_int(4, 13058383) == 52233532);
  assert(mult_int(4, 13058384) == 52233536);
  assert(mult_int(4, 13058385) == 52233540);
  assert(mult_int(4, 13058386) == 52233544);
  assert(mult_int(4, 13058387) == 52233548);
  assert(mult_int(4, 13058388) == 52233552);
  assert(mult_int(4, 13058389) == 52233556);
  assert(mult_int(4, 13058390) == 52233560);
  assert(mult_int(4, 13058391) == 52233564);
  assert(mult_int(4, 13058392) == 52233568);
  assert(mult_int(4, 13058393) == 52233572);
  assert(mult_int(4, 13058394) == 52233576);
  assert(mult_int(4, 13058395) == 52233580);
  assert(mult_int(4, 13058396) == 52233584);
  assert(mult_int(4, 13058397) == 52233588);
  assert(mult_int(4, 13058398) == 52233592);
  assert(mult_int(4, 13058399) == 52233596);
  assert(mult_int(4, 13058400) == 52233600);
  assert(mult_int(4, 13058401) == 52233604);
  assert(mult_int(4, 13058402) == 52233608);
  assert(mult_int(4, 13058403) == 52233612);
  assert(mult_int(4, 13058404) == 52233616);
  assert(mult_int(4, 13058405) == 52233620);
  assert(mult_int(4, 13058406) == 52233624);
  assert(mult_int(4, 13058407) == 52233628);
  assert(mult_int(4, 13058408) == 52233632);
  assert(mult_int(4, 13058409) == 52233636);
  assert(mult_int(4, 13058410) == 52233640);
  assert(mult_int(4, 13058411) == 52233644);
  assert(mult_int(4, 13058412) == 52233648);
  assert(mult_int(4, 13058413) == 52233652);
  assert(mult_int(4, 13058414) == 52233656);
  assert(mult_int(4, 13058415) == 52233660);
  assert(mult_int(4, 13058416) == 52233664);
  assert(mult_int(4, 13058417) == 52233668);
  assert(mult_int(4, 13058418) == 52233672);
  assert(mult_int(4, 13058419) == 52233676);
  assert(mult_int(4, 13058420) == 52233680);
  assert(mult_int(4, 13058421) == 52233684);
  assert(mult_int(4, 13058422) == 52233688);
  assert(mult_int(4, 13058423) == 52233692);
  assert(mult_int(4, 13058424) == 52233696);
  assert(mult_int(4, 13058425) == 52233700);
  assert(mult_int(4, 13058426) == 52233704);
  assert(mult_int(4, 13058427) == 52233708);
  assert(mult_int(4, 13058428) == 52233712);
  assert(mult_int(4, 13058429) == 52233716);
  assert(mult_int(4, 13058430) == 52233720);
  assert(mult_int(4, 13058431) == 52233724);
  assert(mult_int(4, 13058432) == 52233728);
  assert(mult_int(4, 13058433) == 52233732);
  assert(mult_int(4, 13058434) == 52233736);
  assert(mult_int(4, 13058435) == 52233740);
  assert(mult_int(4, 13058436) == 52233744);
  assert(mult_int(4, 13058437) == 52233748);
  assert(mult_int(4, 13058438) == 52233752);
  assert(mult_int(4, 13058439) == 52233756);
  assert(mult_int(4, 13058440) == 52233760);
  assert(mult_int(4, 13058441) == 52233764);
  assert(mult_int(4, 13058442) == 52233768);
  assert(mult_int(4, 13058443) == 52233772);
  assert(mult_int(4, 13058444) == 52233776);
  assert(mult_int(4, 13058445) == 52233780);
  assert(mult_int(4, 13058446) == 52233784);
  assert(mult_int(4, 13058447) == 52233788);
  assert(mult_int(4, 13058448) == 52233792);
  assert(mult_int(4, 13058449) == 52233796);
  assert(mult_int(4, 13058450) == 52233800);
  assert(mult_int(4, 13058451) == 52233804);
  assert(mult_int(4, 13058452) == 52233808);
  assert(mult_int(4, 13058453) == 52233812);
  assert(mult_int(4, 13058454) == 52233816);
  assert(mult_int(4, 13058455) == 52233820);
  assert(mult_int(4, 13058456) == 52233824);
  assert(mult_int(4, 13058457) == 52233828);
  assert(mult_int(4, 13058458) == 52233832);
  assert(mult_int(4, 13058459) == 52233836);
  assert(mult_int(4, 13058460) == 52233840);
  assert(mult_int(4, 13058461) == 52233844);
  assert(mult_int(4, 13058462) == 52233848);
  assert(mult_int(4, 13058463) == 52233852);
  assert(mult_int(4, 13058464) == 52233856);
  assert(mult_int(4, 13058465) == 52233860);
  assert(mult_int(4, 13058466) == 52233864);
  assert(mult_int(4, 13058467) == 52233868);
  assert(mult_int(4, 13058468) == 52233872);
  assert(mult_int(4, 13058469) == 52233876);
  assert(mult_int(4, 13058470) == 52233880);
  assert(mult_int(4, 13058476) == 52233904);
  assert(mult_int(4, 13058477) == 52233908);
  assert(mult_int(4, 13058478) == 52233912);
  assert(mult_int(4, 13058479) == 52233916);
  assert(mult_int(4, 13058480) == 52233920);
  assert(mult_int(4, 13058481) == 52233924);
  assert(mult_int(4, 13058482) == 52233928);
  assert(mult_int(4, 13058483) == 52233932);
  assert(mult_int(4, 13058484) == 52233936);
  assert(mult_int(4, 13058485) == 52233940);
  assert(mult_int(4, 13058486) == 52233944);
  assert(mult_int(4, 13058487) == 52233948);
  assert(mult_int(4, 13058488) == 52233952);
  assert(mult_int(4, 13058489) == 52233956);
  assert(mult_int(4, 13058490) == 52233960);
  assert(mult_int(4, 13058496) == 52233984);
  assert(mult_int(4, 13058497) == 52233988);
  assert(mult_int(4, 13058498) == 52233992);
  assert(mult_int(4, 13058499) == 52233996);
  assert(mult_int(4, 13058500) == 52234000);
  assert(mult_int(4, 13058501) == 52234004);
  assert(mult_int(4, 13058502) == 52234008);
  assert(mult_int(4, 13058503) == 52234012);
  assert(mult_int(4, 13058504) == 52234016);
  assert(mult_int(4, 13058505) == 52234020);
  assert(mult_int(4, 13058511) == 52234044);
  assert(mult_int(4, 13058512) == 52234048);
  assert(mult_int(4, 13058513) == 52234052);
  assert(mult_int(4, 13058514) == 52234056);
  assert(mult_int(4, 13058515) == 52234060);
  assert(mult_int(4, 13058516) == 52234064);
  assert(mult_int(4, 13058517) == 52234068);
  assert(mult_int(4, 13058518) == 52234072);
  assert(mult_int(4, 13058519) == 52234076);
  assert(mult_int(4, 13058520) == 52234080);
  assert(mult_int(4, 13058521) == 52234084);
  assert(mult_int(4, 13058522) == 52234088);
  assert(mult_int(4, 13058523) == 52234092);
  assert(mult_int(4, 13058524) == 52234096);
  assert(mult_int(4, 13058525) == 52234100);
  assert(mult_int(4, 13058526) == 52234104);
  assert(mult_int(4, 13058527) == 52234108);
  assert(mult_int(4, 13058528) == 52234112);
  assert(mult_int(4, 13058529) == 52234116);
  assert(mult_int(4, 13058530) == 52234120);
  assert(mult_int(4, 13058531) == 52234124);
  assert(mult_int(4, 13058532) == 52234128);
  assert(mult_int(4, 13058550) == 52234200);
  assert(mult_int(4, 13058551) == 52234204);
  assert(mult_int(4, 13058552) == 52234208);
  assert(mult_int(4, 13058553) == 52234212);
  assert(mult_int(4, 13058554) == 52234216);
  assert(mult_int(4, 13058555) == 52234220);
  assert(mult_int(4, 13058556) == 52234224);
  assert(mult_int(4, 13058557) == 52234228);
  assert(mult_int(4, 13058558) == 52234232);
  assert(mult_int(4, 13058559) == 52234236);
  assert(mult_int(4, 13058560) == 52234240);
  assert(mult_int(4, 13058561) == 52234244);
  assert(mult_int(4, 13058562) == 52234248);
  assert(mult_int(4, 13058563) == 52234252);
  assert(mult_int(4, 13058564) == 52234256);
  assert(mult_int(4, 13058565) == 52234260);
  assert(mult_int(4, 13058566) == 52234264);
  assert(mult_int(4, 13058567) == 52234268);
  assert(mult_int(4, 13058568) == 52234272);
  assert(mult_int(4, 13058569) == 52234276);
  assert(mult_int(4, 13058570) == 52234280);
  assert(mult_int(4, 13058571) == 52234284);
  assert(mult_int(4, 13058572) == 52234288);
  assert(mult_int(4, 13058573) == 52234292);
  assert(mult_int(4, 13058574) == 52234296);
  assert(mult_int(4, 13058575) == 52234300);
  assert(mult_int(4, 13058576) == 52234304);
  assert(mult_int(4, 13058577) == 52234308);
  assert(mult_int(4, 13058578) == 52234312);
  assert(mult_int(4, 13058579) == 52234316);
  assert(mult_int(4, 13058580) == 52234320);
  assert(mult_int(4, 13058581) == 52234324);
  assert(mult_int(4, 13058582) == 52234328);
  assert(mult_int(4, 13058583) == 52234332);
  assert(mult_int(4, 13058584) == 52234336);
  assert(mult_int(4, 13058585) == 52234340);
  assert(mult_int(4, 13058586) == 52234344);
  assert(mult_int(4, 13058587) == 52234348);
  assert(mult_int(4, 13058588) == 52234352);
  assert(mult_int(4, 13058589) == 52234356);
  assert(mult_int(4, 13058602) == 52234408);
  assert(mult_int(4, 13058603) == 52234412);
  assert(mult_int(4, 13058604) == 52234416);
  assert(mult_int(4, 13058605) == 52234420);
  assert(mult_int(4, 13058606) == 52234424);
  assert(mult_int(4, 13058607) == 52234428);
  assert(mult_int(4, 13058608) == 52234432);
  assert(mult_int(4, 13058609) == 52234436);
  assert(mult_int(4, 13058610) == 52234440);
  assert(mult_int(4, 13058611) == 52234444);
  assert(mult_int(4, 13058612) == 52234448);
  assert(mult_int(4, 13058613) == 52234452);
  assert(mult_int(4, 13058614) == 52234456);
  assert(mult_int(4, 13058615) == 52234460);
  assert(mult_int(4, 13058616) == 52234464);
  assert(mult_int(4, 13058617) == 52234468);
  assert(mult_int(4, 13058618) == 52234472);
  assert(mult_int(4, 13058619) == 52234476);
  assert(mult_int(4, 13058620) == 52234480);
  assert(mult_int(4, 13058621) == 52234484);
  assert(mult_int(4, 13058623) == 52234492);
  assert(mult_int(4, 13058624) == 52234496);
  assert(mult_int(4, 13058625) == 52234500);
  assert(mult_int(4, 13058626) == 52234504);
  assert(mult_int(4, 13058627) == 52234508);
  assert(mult_int(4, 13058628) == 52234512);
  assert(mult_int(4, 13058629) == 52234516);
  assert(mult_int(4, 13058630) == 52234520);
  assert(mult_int(4, 13058631) == 52234524);
  assert(mult_int(4, 13058632) == 52234528);
  assert(mult_int(4, 13058633) == 52234532);
  assert(mult_int(4, 13058634) == 52234536);
  assert(mult_int(4, 13058635) == 52234540);
  assert(mult_int(4, 13058636) == 52234544);
  assert(mult_int(4, 13058637) == 52234548);
  assert(mult_int(4, 13058638) == 52234552);
  assert(mult_int(4, 13058639) == 52234556);
  assert(mult_int(4, 13058640) == 52234560);
  assert(mult_int(4, 13058641) == 52234564);
  assert(mult_int(4, 13058642) == 52234568);
  assert(mult_int(4, 13058643) == 52234572);
  assert(mult_int(4, 13058644) == 52234576);
  assert(mult_int(4, 13058645) == 52234580);
  assert(mult_int(4, 13058646) == 52234584);
  assert(mult_int(4, 13058647) == 52234588);
  assert(mult_int(4, 13058648) == 52234592);
  assert(mult_int(4, 13058649) == 52234596);
  assert(mult_int(4, 13058650) == 52234600);
  assert(mult_int(4, 13058651) == 52234604);
  assert(mult_int(4, 13058652) == 52234608);
  assert(mult_int(4, 13058653) == 52234612);
  assert(mult_int(4, 13058654) == 52234616);
  assert(mult_int(4, 13058655) == 52234620);
  assert(mult_int(4, 13058656) == 52234624);
  assert(mult_int(4, 13058657) == 52234628);
  assert(mult_int(4, 13058658) == 52234632);
  assert(mult_int(4, 13058659) == 52234636);
  assert(mult_int(4, 13058660) == 52234640);
  assert(mult_int(4, 13058661) == 52234644);
  assert(mult_int(4, 13058662) == 52234648);
  assert(mult_int(4, 13058663) == 52234652);
  assert(mult_int(4, 13058664) == 52234656);
  assert(mult_int(4, 13058665) == 52234660);
  assert(mult_int(4, 13058666) == 52234664);
  assert(mult_int(4, 13058667) == 52234668);
  assert(mult_int(4, 13058668) == 52234672);
  assert(mult_int(4, 13058669) == 52234676);
  assert(mult_int(4, 13058670) == 52234680);
  assert(mult_int(4, 13058671) == 52234684);
  assert(mult_int(4, 13058672) == 52234688);
  assert(mult_int(4, 13058673) == 52234692);
  assert(mult_int(4, 13058674) == 52234696);
  assert(mult_int(4, 13058675) == 52234700);
  assert(mult_int(4, 13058676) == 52234704);
  assert(mult_int(4, 13058677) == 52234708);
  assert(mult_int(4, 13058679) == 52234716);
  assert(mult_int(4, 13058680) == 52234720);
  assert(mult_int(4, 13058681) == 52234724);
  assert(mult_int(4, 13058682) == 52234728);
  assert(mult_int(4, 13058683) == 52234732);
  assert(mult_int(4, 13058684) == 52234736);
  assert(mult_int(4, 13058685) == 52234740);
  assert(mult_int(4, 13058686) == 52234744);
  assert(mult_int(4, 13058687) == 52234748);
  assert(mult_int(4, 13058690) == 52234760);
  assert(mult_int(4, 13058691) == 52234764);
  assert(mult_int(4, 13058692) == 52234768);
  assert(mult_int(4, 13058693) == 52234772);
  assert(mult_int(4, 13058694) == 52234776);
  assert(mult_int(4, 13058695) == 52234780);
  assert(mult_int(4, 13058696) == 52234784);
  assert(mult_int(4, 13058697) == 52234788);
  assert(mult_int(4, 13058698) == 52234792);
  assert(mult_int(4, 13058699) == 52234796);
  assert(mult_int(4, 13058700) == 52234800);
  assert(mult_int(4, 13058701) == 52234804);
  assert(mult_int(4, 13058702) == 52234808);
  assert(mult_int(4, 13058703) == 52234812);
  assert(mult_int(4, 13058704) == 52234816);
  assert(mult_int(4, 13058705) == 52234820);
  assert(mult_int(4, 13058706) == 52234824);
  assert(mult_int(4, 13058707) == 52234828);
  assert(mult_int(4, 13058708) == 52234832);
  assert(mult_int(4, 13058709) == 52234836);
  assert(mult_int(4, 13058710) == 52234840);
  assert(mult_int(4, 13058711) == 52234844);
  assert(mult_int(4, 13058712) == 52234848);
  assert(mult_int(4, 13058713) == 52234852);
  assert(mult_int(4, 13058714) == 52234856);
  assert(mult_int(4, 13058715) == 52234860);
  assert(mult_int(4, 13058716) == 52234864);
  assert(mult_int(4, 13058717) == 52234868);
  assert(mult_int(4, 13058718) == 52234872);
  assert(mult_int(4, 13058719) == 52234876);
  assert(mult_int(4, 13058720) == 52234880);
  assert(mult_int(4, 13058721) == 52234884);
  assert(mult_int(4, 13058722) == 52234888);
  assert(mult_int(4, 13058723) == 52234892);
  assert(mult_int(4, 13058724) == 52234896);
  assert(mult_int(4, 13058725) == 52234900);
  assert(mult_int(4, 13058726) == 52234904);
  assert(mult_int(4, 13058727) == 52234908);
  assert(mult_int(4, 13058728) == 52234912);
  assert(mult_int(4, 13058729) == 52234916);
  assert(mult_int(4, 13058730) == 52234920);
  assert(mult_int(4, 13058731) == 52234924);
  assert(mult_int(4, 13058732) == 52234928);
  assert(mult_int(4, 13058733) == 52234932);
  assert(mult_int(4, 13058734) == 52234936);
  assert(mult_int(4, 13058735) == 52234940);
  assert(mult_int(4, 13058736) == 52234944);
  assert(mult_int(4, 13058737) == 52234948);
  assert(mult_int(4, 13058738) == 52234952);
  assert(mult_int(4, 13058739) == 52234956);
  assert(mult_int(4, 13058740) == 52234960);
  assert(mult_int(4, 13058741) == 52234964);
  assert(mult_int(4, 13058742) == 52234968);
  assert(mult_int(4, 13058743) == 52234972);
  assert(mult_int(4, 13058744) == 52234976);
  assert(mult_int(4, 13058745) == 52234980);
  assert(mult_int(4, 13058746) == 52234984);
  assert(mult_int(4, 13058747) == 52234988);
  assert(mult_int(4, 13058748) == 52234992);
  assert(mult_int(4, 13058749) == 52234996);
  assert(mult_int(4, 13058750) == 52235000);
  assert(mult_int(4, 13058754) == 52235016);
  assert(mult_int(4, 13058755) == 52235020);
  assert(mult_int(4, 13058756) == 52235024);
  assert(mult_int(4, 13058757) == 52235028);
  assert(mult_int(4, 13058758) == 52235032);
  assert(mult_int(4, 13058759) == 52235036);
  assert(mult_int(4, 13058760) == 52235040);
  assert(mult_int(4, 13058761) == 52235044);
  assert(mult_int(4, 13058762) == 52235048);
  assert(mult_int(4, 13058765) == 52235060);
  assert(mult_int(4, 13058766) == 52235064);
  assert(mult_int(4, 13058767) == 52235068);
  assert(mult_int(4, 13058768) == 52235072);
  assert(mult_int(4, 13058772) == 52235088);
  assert(mult_int(4, 13058773) == 52235092);
  assert(mult_int(4, 13058774) == 52235096);
  assert(mult_int(4, 13058775) == 52235100);
  assert(mult_int(4, 13058776) == 52235104);
  assert(mult_int(4, 13058777) == 52235108);
  assert(mult_int(4, 13058778) == 52235112);
  assert(mult_int(4, 13058779) == 52235116);
  assert(mult_int(4, 13058780) == 52235120);
  assert(mult_int(4, 13058781) == 52235124);
  assert(mult_int(4, 13058782) == 52235128);
  assert(mult_int(4, 13058783) == 52235132);
  assert(mult_int(4, 13058784) == 52235136);
  assert(mult_int(4, 13058785) == 52235140);
  assert(mult_int(4, 13058786) == 52235144);
  assert(mult_int(4, 13058787) == 52235148);
  assert(mult_int(4, 13058788) == 52235152);
  assert(mult_int(4, 13058789) == 52235156);
  assert(mult_int(4, 13058790) == 52235160);
  assert(mult_int(4, 13058791) == 52235164);
  assert(mult_int(4, 13058792) == 52235168);
  assert(mult_int(4, 13058793) == 52235172);
  assert(mult_int(4, 13058794) == 52235176);
  assert(mult_int(4, 13058795) == 52235180);
  assert(mult_int(4, 13058796) == 52235184);
  assert(mult_int(4, 13058797) == 52235188);
  assert(mult_int(4, 13058798) == 52235192);
  assert(mult_int(4, 13058799) == 52235196);
  assert(mult_int(4, 13058800) == 52235200);
  assert(mult_int(4, 13058801) == 52235204);
  assert(mult_int(4, 13058802) == 52235208);
  assert(mult_int(4, 13058803) == 52235212);
  assert(mult_int(4, 13058804) == 52235216);
  assert(mult_int(4, 13058805) == 52235220);
  assert(mult_int(4, 13058806) == 52235224);
  assert(mult_int(4, 13058807) == 52235228);
  assert(mult_int(4, 13058808) == 52235232);
  assert(mult_int(4, 13058809) == 52235236);
  assert(mult_int(4, 13058810) == 52235240);
  assert(mult_int(4, 13058811) == 52235244);
  assert(mult_int(4, 13058812) == 52235248);
  assert(mult_int(4, 13058813) == 52235252);
  assert(mult_int(4, 13058814) == 52235256);
  assert(mult_int(4, 13058815) == 52235260);
  assert(mult_int(4, 13058816) == 52235264);
  assert(mult_int(4, 13058817) == 52235268);
  assert(mult_int(4, 13058818) == 52235272);
  assert(mult_int(4, 13058819) == 52235276);
  assert(mult_int(4, 13058823) == 52235292);
  assert(mult_int(4, 13058824) == 52235296);
  assert(mult_int(4, 13058825) == 52235300);
  assert(mult_int(4, 13058826) == 52235304);
  assert(mult_int(4, 13058827) == 52235308);
  assert(mult_int(4, 13058828) == 52235312);
  assert(mult_int(4, 13058829) == 52235316);
  assert(mult_int(4, 13058830) == 52235320);
  assert(mult_int(4, 13058831) == 52235324);
  assert(mult_int(4, 13058834) == 52235336);
  assert(mult_int(4, 13058835) == 52235340);
  assert(mult_int(4, 13058836) == 52235344);
  assert(mult_int(4, 13058837) == 52235348);
  assert(mult_int(4, 13058841) == 52235364);
  assert(mult_int(4, 13058842) == 52235368);
  assert(mult_int(4, 13058843) == 52235372);
  assert(mult_int(4, 13058844) == 52235376);
  assert(mult_int(4, 13058845) == 52235380);
  assert(mult_int(4, 13058846) == 52235384);
  assert(mult_int(4, 13058847) == 52235388);
  assert(mult_int(4, 13058848) == 52235392);
  assert(mult_int(4, 13058849) == 52235396);
  assert(mult_int(4, 13058850) == 52235400);
  assert(mult_int(4, 13058851) == 52235404);
  assert(mult_int(4, 13058852) == 52235408);
  assert(mult_int(4, 13058853) == 52235412);
  assert(mult_int(4, 13058854) == 52235416);
  assert(mult_int(4, 13058855) == 52235420);
  assert(mult_int(4, 13058856) == 52235424);
  assert(mult_int(4, 13058857) == 52235428);
  assert(mult_int(4, 13058858) == 52235432);
  assert(mult_int(4, 13058859) == 52235436);
  assert(mult_int(4, 13058860) == 52235440);
  assert(mult_int(4, 13058861) == 52235444);
  assert(mult_int(4, 13058862) == 52235448);
  assert(mult_int(4, 13058863) == 52235452);
  assert(mult_int(4, 13058864) == 52235456);
  assert(mult_int(4, 13058865) == 52235460);
  assert(mult_int(4, 13058866) == 52235464);
  assert(mult_int(4, 13058867) == 52235468);
  assert(mult_int(4, 13058868) == 52235472);
  assert(mult_int(4, 13058869) == 52235476);
  assert(mult_int(4, 13058870) == 52235480);
  assert(mult_int(4, 13058871) == 52235484);
  assert(mult_int(4, 13058872) == 52235488);
  assert(mult_int(4, 13058873) == 52235492);
  assert(mult_int(4, 13058874) == 52235496);
  assert(mult_int(4, 13058875) == 52235500);
  assert(mult_int(4, 13058876) == 52235504);
  assert(mult_int(4, 13058877) == 52235508);
  assert(mult_int(4, 13058878) == 52235512);
  assert(mult_int(4, 13058879) == 52235516);
  assert(mult_int(4, 13058880) == 52235520);
  assert(mult_int(4, 13058881) == 52235524);
  assert(mult_int(4, 13058882) == 52235528);
  assert(mult_int(4, 13058883) == 52235532);
  assert(mult_int(4, 13058884) == 52235536);
  assert(mult_int(4, 13058885) == 52235540);
  assert(mult_int(4, 13058889) == 52235556);
  assert(mult_int(4, 13058890) == 52235560);
  assert(mult_int(4, 13058891) == 52235564);
  assert(mult_int(4, 13058892) == 52235568);
  assert(mult_int(4, 13058893) == 52235572);
  assert(mult_int(4, 13058894) == 52235576);
  assert(mult_int(4, 13058895) == 52235580);
  assert(mult_int(4, 13058898) == 52235592);
  assert(mult_int(4, 13058899) == 52235596);
  assert(mult_int(4, 13058900) == 52235600);
  assert(mult_int(4, 13058901) == 52235604);
  assert(mult_int(4, 13058905) == 52235620);
  assert(mult_int(4, 13058906) == 52235624);
  assert(mult_int(4, 13058907) == 52235628);
  assert(mult_int(4, 13058908) == 52235632);
  assert(mult_int(4, 13058909) == 52235636);
  assert(mult_int(4, 13058910) == 52235640);
  assert(mult_int(4, 13058911) == 52235644);
  assert(mult_int(4, 13058912) == 52235648);
  assert(mult_int(4, 13058913) == 52235652);
  assert(mult_int(4, 13058914) == 52235656);
  assert(mult_int(4, 13058915) == 52235660);
  assert(mult_int(4, 13058916) == 52235664);
  assert(mult_int(4, 13058917) == 52235668);
  assert(mult_int(4, 13058918) == 52235672);
  assert(mult_int(4, 13058919) == 52235676);
  assert(mult_int(4, 13058920) == 52235680);
  assert(mult_int(4, 13058921) == 52235684);
  assert(mult_int(4, 13058922) == 52235688);
  assert(mult_int(4, 13058923) == 52235692);
  assert(mult_int(4, 13058924) == 52235696);
  assert(mult_int(4, 13058925) == 52235700);
  assert(mult_int(4, 13058926) == 52235704);
  assert(mult_int(4, 13058927) == 52235708);
  assert(mult_int(4, 13058928) == 52235712);
  assert(mult_int(4, 13058929) == 52235716);
  assert(mult_int(4, 13058930) == 52235720);
  assert(mult_int(4, 13058931) == 52235724);
  assert(mult_int(4, 13058932) == 52235728);
  assert(mult_int(4, 13058933) == 52235732);
  assert(mult_int(4, 13058934) == 52235736);
  assert(mult_int(4, 13058935) == 52235740);
  assert(mult_int(4, 13058936) == 52235744);
  assert(mult_int(4, 13058937) == 52235748);
  assert(mult_int(4, 13058938) == 52235752);
  assert(mult_int(4, 13058939) == 52235756);
  assert(mult_int(4, 13058940) == 52235760);
  assert(mult_int(4, 13058941) == 52235764);
  assert(mult_int(4, 13058942) == 52235768);
  assert(mult_int(4, 13058943) == 52235772);
  assert(mult_int(4, 13058944) == 52235776);
  assert(mult_int(4, 13058945) == 52235780);
  assert(mult_int(4, 13058946) == 52235784);
  assert(mult_int(4, 13058947) == 52235788);
  assert(mult_int(4, 13058948) == 52235792);
  assert(mult_int(4, 13058949) == 52235796);
  assert(mult_int(4, 13058950) == 52235800);
  assert(mult_int(4, 13058951) == 52235804);
  assert(mult_int(4, 13058952) == 52235808);
  assert(mult_int(4, 13058953) == 52235812);
  assert(mult_int(4, 13058954) == 52235816);
  assert(mult_int(4, 13058955) == 52235820);
  assert(mult_int(4, 13058956) == 52235824);
  assert(mult_int(4, 13058957) == 52235828);
  assert(mult_int(4, 13058958) == 52235832);
  assert(mult_int(4, 13058966) == 52235864);
  assert(mult_int(4, 13058967) == 52235868);
  assert(mult_int(4, 13058968) == 52235872);
  assert(mult_int(4, 13058969) == 52235876);
  assert(mult_int(4, 13058970) == 52235880);
  assert(mult_int(4, 13058971) == 52235884);
  assert(mult_int(4, 13058972) == 52235888);
  assert(mult_int(4, 13058973) == 52235892);
  assert(mult_int(4, 13058974) == 52235896);
  assert(mult_int(4, 13058975) == 52235900);
  assert(mult_int(4, 13058976) == 52235904);
  assert(mult_int(4, 13058977) == 52235908);
  assert(mult_int(4, 13058978) == 52235912);
  assert(mult_int(4, 13058979) == 52235916);
  assert(mult_int(4, 13059023) == 52236092);
  assert(mult_int(4, 13059024) == 52236096);
  assert(mult_int(4, 13059025) == 52236100);
  assert(mult_int(4, 13059026) == 52236104);
  assert(mult_int(4, 13059027) == 52236108);
  assert(mult_int(4, 13059028) == 52236112);
  assert(mult_int(4, 13059029) == 52236116);
  assert(mult_int(4, 13059030) == 52236120);
  assert(mult_int(4, 13059031) == 52236124);
  assert(mult_int(4, 13059032) == 52236128);
  assert(mult_int(4, 13059033) == 52236132);
  assert(mult_int(4, 13059034) == 52236136);
  assert(mult_int(4, 13059035) == 52236140);
  assert(mult_int(4, 13059036) == 52236144);
  assert(mult_int(4, 13059037) == 52236148);
  assert(mult_int(4, 13059038) == 52236152);
  assert(mult_int(4, 13059039) == 52236156);
  assert(mult_int(4, 13059043) == 52236172);
  assert(mult_int(4, 13059044) == 52236176);
  assert(mult_int(4, 13059045) == 52236180);
  assert(mult_int(4, 13059046) == 52236184);
  assert(mult_int(4, 13059047) == 52236188);
  assert(mult_int(4, 13059048) == 52236192);
  assert(mult_int(4, 13059052) == 52236208);
  assert(mult_int(4, 13059053) == 52236212);
  assert(mult_int(4, 13059054) == 52236216);
  assert(mult_int(4, 13059055) == 52236220);
  assert(mult_int(4, 13059056) == 52236224);
  assert(mult_int(4, 13059057) == 52236228);
  assert(mult_int(4, 13059095) == 52236380);
  assert(mult_int(4, 13059096) == 52236384);
  assert(mult_int(4, 13059097) == 52236388);
  assert(mult_int(4, 13059098) == 52236392);
  assert(mult_int(4, 13059099) == 52236396);
  assert(mult_int(4, 13059102) == 52236408);
  assert(mult_int(4, 13059103) == 52236412);
  assert(mult_int(4, 13059104) == 52236416);
  assert(mult_int(4, 13059105) == 52236420);
  assert(mult_int(4, 13059106) == 52236424);
  assert(mult_int(4, 13059107) == 52236428);
  assert(mult_int(4, 13059108) == 52236432);
  assert(mult_int(4, 13059109) == 52236436);
  assert(mult_int(4, 13059112) == 52236448);
  assert(mult_int(4, 13059113) == 52236452);
  assert(mult_int(4, 13059118) == 52236472);
  assert(mult_int(4, 13059119) == 52236476);
  assert(mult_int(4, 13059120) == 52236480);
  assert(mult_int(4, 13059121) == 52236484);
  assert(mult_int(4, 13059122) == 52236488);
  assert(mult_int(4, 13059123) == 52236492);
  assert(mult_int(4, 13059124) == 52236496);
  assert(mult_int(4, 13059125) == 52236500);
  assert(mult_int(4, 13059126) == 52236504);
  assert(mult_int(4, 13059127) == 52236508);
  assert(mult_int(4, 13059128) == 52236512);
  assert(mult_int(4, 13059129) == 52236516);
  assert(mult_int(4, 13059130) == 52236520);
  assert(mult_int(4, 13059131) == 52236524);
  assert(mult_int(4, 13059132) == 52236528);
  assert(mult_int(4, 13059133) == 52236532);
  assert(mult_int(4, 13059142) == 52236568);
  assert(mult_int(4, 13059143) == 52236572);
  assert(mult_int(4, 13059144) == 52236576);
  assert(mult_int(4, 13059145) == 52236580);
  assert(mult_int(4, 13059146) == 52236584);
  assert(mult_int(4, 13059147) == 52236588);
  assert(mult_int(4, 13059148) == 52236592);
  assert(mult_int(4, 13059149) == 52236596);
  assert(mult_int(4, 13059150) == 52236600);
  assert(mult_int(4, 13059151) == 52236604);
  assert(mult_int(4, 13059152) == 52236608);
  assert(mult_int(4, 13059153) == 52236612);
  assert(mult_int(4, 13059154) == 52236616);
  assert(mult_int(4, 13059155) == 52236620);
  assert(mult_int(4, 13059156) == 52236624);
  assert(mult_int(4, 13059157) == 52236628);
  assert(mult_int(4, 13059158) == 52236632);
  assert(mult_int(4, 13059159) == 52236636);
  assert(mult_int(4, 13059160) == 52236640);
  assert(mult_int(4, 13059161) == 52236644);
  assert(mult_int(4, 13059168) == 52236672);
  assert(mult_int(4, 13059169) == 52236676);
  assert(mult_int(4, 13059170) == 52236680);
  assert(mult_int(4, 13059171) == 52236684);
  assert(mult_int(4, 13059172) == 52236688);
  assert(mult_int(4, 13059173) == 52236692);
  assert(mult_int(4, 13059174) == 52236696);
  assert(mult_int(4, 13059175) == 52236700);
  assert(mult_int(4, 13059176) == 52236704);
  assert(mult_int(4, 13059177) == 52236708);
  assert(mult_int(4, 13059178) == 52236712);
  assert(mult_int(4, 13059179) == 52236716);
  assert(mult_int(4, 13059180) == 52236720);
  assert(mult_int(4, 13059181) == 52236724);
  assert(mult_int(4, 13059182) == 52236728);
  assert(mult_int(4, 13059183) == 52236732);
  assert(mult_int(4, 13059184) == 52236736);
  assert(mult_int(4, 13059185) == 52236740);
  assert(mult_int(4, 13059186) == 52236744);
  assert(mult_int(4, 13059187) == 52236748);
  assert(mult_int(4, 13059188) == 52236752);
  assert(mult_int(4, 13059189) == 52236756);
  assert(mult_int(4, 13059190) == 52236760);
  assert(mult_int(4, 13059191) == 52236764);
  assert(mult_int(4, 13059192) == 52236768);
  assert(mult_int(4, 13059195) == 52236780);
  assert(mult_int(4, 13059196) == 52236784);
  assert(mult_int(4, 13059198) == 52236792);
  assert(mult_int(4, 13059199) == 52236796);
  assert(mult_int(4, 13059200) == 52236800);
  assert(mult_int(4, 13059201) == 52236804);
  assert(mult_int(4, 13059202) == 52236808);
  assert(mult_int(4, 13059203) == 52236812);
  assert(mult_int(4, 13059208) == 52236832);
  assert(mult_int(4, 13059209) == 52236836);
  assert(mult_int(4, 13059221) == 52236884);
  assert(mult_int(4, 13059222) == 52236888);
  assert(mult_int(4, 13059223) == 52236892);
  assert(mult_int(4, 13059239) == 52236956);
  assert(mult_int(4, 13059240) == 52236960);
  assert(mult_int(4, 13059241) == 52236964);
  assert(mult_int(4, 13059242) == 52236968);
  assert(mult_int(4, 13059243) == 52236972);
  assert(mult_int(4, 13059244) == 52236976);
  assert(mult_int(4, 13059245) == 52236980);
  assert(mult_int(4, 13059246) == 52236984);
  assert(mult_int(4, 13059247) == 52236988);
  assert(mult_int(4, 13059248) == 52236992);
  assert(mult_int(4, 13059249) == 52236996);
  assert(mult_int(4, 13059250) == 52237000);
  assert(mult_int(4, 13059251) == 52237004);
  assert(mult_int(4, 13059252) == 52237008);
  assert(mult_int(4, 13059253) == 52237012);
  assert(mult_int(4, 13059254) == 52237016);
  assert(mult_int(4, 13059255) == 52237020);
  assert(mult_int(4, 13059256) == 52237024);
  assert(mult_int(4, 13059257) == 52237028);
  assert(mult_int(4, 13059258) == 52237032);
  assert(mult_int(4, 13059259) == 52237036);
  assert(mult_int(4, 13059260) == 52237040);
  assert(mult_int(4, 13059261) == 52237044);
  assert(mult_int(4, 13059262) == 52237048);
  assert(mult_int(4, 13059263) == 52237052);
  assert(mult_int(4, 13059264) == 52237056);
  assert(mult_int(4, 13059265) == 52237060);
  assert(mult_int(4, 13059266) == 52237064);
  assert(mult_int(4, 13059267) == 52237068);
  assert(mult_int(4, 13059268) == 52237072);
  assert(mult_int(4, 13059269) == 52237076);
  assert(mult_int(4, 13059270) == 52237080);
  assert(mult_int(4, 13059271) == 52237084);
  assert(mult_int(4, 13059272) == 52237088);
  assert(mult_int(4, 13059273) == 52237092);
  assert(mult_int(4, 13059274) == 52237096);
  assert(mult_int(4, 13059275) == 52237100);
  assert(mult_int(4, 13059276) == 52237104);
  assert(mult_int(4, 13059277) == 52237108);
  assert(mult_int(4, 13059278) == 52237112);
  assert(mult_int(4, 13059279) == 52237116);
  assert(mult_int(4, 13059280) == 52237120);
  assert(mult_int(4, 13059281) == 52237124);
  assert(mult_int(4, 13059282) == 52237128);
  assert(mult_int(4, 13059283) == 52237132);
  assert(mult_int(4, 13059284) == 52237136);
  assert(mult_int(4, 13059285) == 52237140);
  assert(mult_int(4, 13059286) == 52237144);
  assert(mult_int(4, 13059287) == 52237148);
  assert(mult_int(4, 13059288) == 52237152);
  assert(mult_int(4, 13059289) == 52237156);
  assert(mult_int(4, 13059290) == 52237160);
  assert(mult_int(4, 13059291) == 52237164);
  assert(mult_int(4, 13059292) == 52237168);
  assert(mult_int(4, 13059293) == 52237172);
  assert(mult_int(4, 13059294) == 52237176);
  assert(mult_int(4, 13059295) == 52237180);
  assert(mult_int(4, 13059296) == 52237184);
  assert(mult_int(4, 13059297) == 52237188);
  assert(mult_int(4, 13059298) == 52237192);
  assert(mult_int(4, 13059550) == 52238200);
  assert(mult_int(4, 13059572) == 52238288);
  assert(mult_int(4, 13059573) == 52238292);
  assert(mult_int(4, 13059580) == 52238320);
  assert(mult_int(4, 13059581) == 52238324);
  assert(mult_int(4, 13059638) == 52238552);
  assert(mult_int(4, 13059850) == 52239400);
  assert(mult_int(4, 13059851) == 52239404);
  assert(mult_int(4, 13059852) == 52239408);
  assert(mult_int(4, 13059853) == 52239412);
  assert(mult_int(4, 13059854) == 52239416);
  assert(mult_int(4, 13059855) == 52239420);
  assert(mult_int(4, 13059856) == 52239424);
  assert(mult_int(4, 13059857) == 52239428);
  assert(mult_int(4, 13059858) == 52239432);
  assert(mult_int(4, 13059859) == 52239436);
  assert(mult_int(4, 13059860) == 52239440);
  assert(mult_int(4, 13059861) == 52239444);
  assert(mult_int(4, 13059862) == 52239448);
  assert(mult_int(4, 13059863) == 52239452);
  assert(mult_int(4, 13059864) == 52239456);
  assert(mult_int(4, 13059865) == 52239460);
  assert(mult_int(4, 13059866) == 52239464);
  assert(mult_int(4, 13059867) == 52239468);
  assert(mult_int(4, 13059868) == 52239472);
  assert(mult_int(4, 13059869) == 52239476);
  assert(mult_int(4, 13059870) == 52239480);
  assert(mult_int(4, 14680070) == 58720280);
  assert(mult_int(4, 14680080) == 58720320);
  assert(mult_int(4, 14680084) == 58720336);
  assert(mult_int(4, 14680300) == 58721200);
  assert(mult_int(4, 14680301) == 58721204);
  assert(mult_int(4, 14680302) == 58721208);
  assert(mult_int(4, 14680303) == 58721212);
  assert(mult_int(4, 14680304) == 58721216);
  assert(mult_int(4, 14680305) == 58721220);
  assert(mult_int(4, 14680306) == 58721224);
  assert(mult_int(4, 14680307) == 58721228);
  assert(mult_int(4, 14680308) == 58721232);
  assert(mult_int(4, 14680309) == 58721236);
  assert(mult_int(4, 14680310) == 58721240);
  assert(mult_int(4, 14680311) == 58721244);
  assert(mult_int(4, 14680312) == 58721248);
  assert(mult_int(4, 14680313) == 58721252);
  assert(mult_int(4, 14680314) == 58721256);
  assert(mult_int(4, 14680315) == 58721260);
  assert(mult_int(4, 14688280) == 58753120);
  assert(mult_int(4, 14688281) == 58753124);
  assert(mult_int(4, 14688404) == 58753616);
  assert(mult_int(4, 14688896) == 58755584);
  assert(mult_int(4, 14688897) == 58755588);
  assert(mult_int(4, 14688992) == 58755968);
  assert(mult_int(4, 14693980) == 58775920);
  assert(mult_int(4, 14693981) == 58775924);
  assert(mult_int(4, 14693982) == 58775928);
  assert(mult_int(4, 14693983) == 58775932);
  assert(mult_int(4, 14693984) == 58775936);
  assert(mult_int(4, 14693985) == 58775940);
  assert(mult_int(4, 14693986) == 58775944);
  assert(mult_int(4, 14693987) == 58775948);
  assert(mult_int(4, 14693988) == 58775952);
  assert(mult_int(4, 14693989) == 58775956);
  assert(mult_int(4, 14693990) == 58775960);
  assert(mult_int(4, 14693991) == 58775964);
  assert(mult_int(4, 14693992) == 58775968);
  assert(mult_int(4, 14693993) == 58775972);
  assert(mult_int(4, 14693994) == 58775976);
  assert(mult_int(4, 14693995) == 58775980);
  assert(mult_int(4, 14701956) == 58807824);
  assert(mult_int(4, 14701961) == 58807844);
  assert(mult_int(4, 14701966) == 58807864);
  assert(mult_int(4, 14701967) == 58807868);
  assert(mult_int(4, 14702048) == 58808192);
  assert(mult_int(4, 14702360) == 58809440);
  assert(mult_int(4, 14706528) == 58826112);
  assert(mult_int(4, 14706529) == 58826116);
  assert(mult_int(4, 14706530) == 58826120);
  assert(mult_int(4, 14706531) == 58826124);
  assert(mult_int(4, 14706612) == 58826448);
  assert(mult_int(4, 14706848) == 58827392);
  assert(mult_int(4, 14706849) == 58827396);
  assert(mult_int(4, 14706850) == 58827400);
  assert(mult_int(4, 14706851) == 58827404);
  assert(mult_int(4, 14706932) == 58827728);
  assert(mult_int(4, 14707168) == 58828672);
  assert(mult_int(4, 14707169) == 58828676);
  assert(mult_int(4, 14707170) == 58828680);
  assert(mult_int(4, 14707172) == 58828688);
  assert(mult_int(4, 14707176) == 58828704);
  assert(mult_int(4, 14707177) == 58828708);
  assert(mult_int(4, 14707179) == 58828716);
  assert(mult_int(4, 14707180) == 58828720);
  assert(mult_int(4, 14707258) == 58829032);
  assert(mult_int(4, 14707568) == 58830272);
  assert(mult_int(4, 14707640) == 58830560);
  assert(mult_int(4, 14707641) == 58830564);
  assert(mult_int(4, 14707642) == 58830568);
  assert(mult_int(4, 14707860) == 58831440);
  assert(mult_int(4, 14707861) == 58831444);
  assert(mult_int(4, 14707862) == 58831448);
  assert(mult_int(4, 14707863) == 58831452);
  assert(mult_int(4, 14707864) == 58831456);
  assert(mult_int(4, 14707865) == 58831460);
  assert(mult_int(4, 14707866) == 58831464);
  assert(mult_int(4, 14707867) == 58831468);
  assert(mult_int(4, 14707868) == 58831472);
  assert(mult_int(4, 14707869) == 58831476);
  assert(mult_int(4, 14707870) == 58831480);
  assert(mult_int(4, 14707871) == 58831484);
  assert(mult_int(4, 14707872) == 58831488);
  assert(mult_int(4, 14707873) == 58831492);
  assert(mult_int(4, 14707874) == 58831496);
  assert(mult_int(4, 14707875) == 58831500);
  assert(mult_int(4, 14707876) == 58831504);
  assert(mult_int(4, 17329) == 69316);
  assert(mult_int(4, 17330) == 69320);
  assert(mult_int(4, 17331) == 69324);
  assert(mult_int(4, 17332) == 69328);
  assert(mult_int(4, 17333) == 69332);
  assert(mult_int(4, 17334) == 69336);
  assert(mult_int(4, 17335) == 69340);
  assert(mult_int(4, 17336) == 69344);
  assert(mult_int(4, 17337) == 69348);
  assert(mult_int(4, 17338) == 69352);
  assert(mult_int(4, 17339) == 69356);
  assert(mult_int(4, 17340) == 69360);
  assert(mult_int(4, 17341) == 69364);
  assert(mult_int(4, 17342) == 69368);
  assert(mult_int(4, 17343) == 69372);
  assert(mult_int(4, 17344) == 69376);
  assert(mult_int(4, 17345) == 69380);
  assert(mult_int(4, 17346) == 69384);
  assert(mult_int(4, 17347) == 69388);
  assert(mult_int(4, 17348) == 69392);
  assert(mult_int(4, 17349) == 69396);
  assert(mult_int(4, 17350) == 69400);
  assert(mult_int(4, 17351) == 69404);
  assert(mult_int(4, 17352) == 69408);
  assert(mult_int(4, 17353) == 69412);
  assert(mult_int(4, 17354) == 69416);
  assert(mult_int(4, 17355) == 69420);
  assert(mult_int(4, 17356) == 69424);
  assert(mult_int(4, 17357) == 69428);
  assert(mult_int(4, 17358) == 69432);
  assert(mult_int(4, 17359) == 69436);
  assert(mult_int(4, 17360) == 69440);
  assert(mult_int(4, 17361) == 69444);
  assert(mult_int(4, 17362) == 69448);
  assert(mult_int(4, 17363) == 69452);
  assert(mult_int(4, 17364) == 69456);
  assert(mult_int(4, 17365) == 69460);
  assert(mult_int(4, 17366) == 69464);
  assert(mult_int(4, 17367) == 69468);
  assert(mult_int(4, 17368) == 69472);
  assert(mult_int(4, 17369) == 69476);
  assert(mult_int(4, 17370) == 69480);
  assert(mult_int(4, 17371) == 69484);
  assert(mult_int(4, 18780) == 75120);
  assert(mult_int(4, 18781) == 75124);
  assert(mult_int(4, 18782) == 75128);
  assert(mult_int(4, 18783) == 75132);
  assert(mult_int(4, 18784) == 75136);
  assert(mult_int(4, 18785) == 75140);
  assert(mult_int(4, 18786) == 75144);
  assert(mult_int(4, 18787) == 75148);
  assert(mult_int(4, 18788) == 75152);
  assert(mult_int(4, 18789) == 75156);
  assert(mult_int(4, 18790) == 75160);
  assert(mult_int(4, 18791) == 75164);
  assert(mult_int(4, 18792) == 75168);
  assert(mult_int(4, 18793) == 75172);
  assert(mult_int(4, 18794) == 75176);
  assert(mult_int(4, 18795) == 75180);
  assert(mult_int(4, 18796) == 75184);
  assert(mult_int(4, 18797) == 75188);
  assert(mult_int(4, 18798) == 75192);
  assert(mult_int(4, 18799) == 75196);
  assert(mult_int(4, 18800) == 75200);
  assert(mult_int(4, 18801) == 75204);
  assert(mult_int(4, 18802) == 75208);
  assert(mult_int(4, 18803) == 75212);
  assert(mult_int(4, 18804) == 75216);
  assert(mult_int(4, 18805) == 75220);
  assert(mult_int(4, 18806) == 75224);
  assert(mult_int(4, 18807) == 75228);
  assert(mult_int(4, 18808) == 75232);
  assert(mult_int(4, 18809) == 75236);
  assert(mult_int(4, 18810) == 75240);
  assert(mult_int(4, 18811) == 75244);
  assert(mult_int(4, 18812) == 75248);
  assert(mult_int(4, 18813) == 75252);
  assert(mult_int(4, 18814) == 75256);
  assert(mult_int(4, 18815) == 75260);
  assert(mult_int(4, 18816) == 75264);
  assert(mult_int(4, 18817) == 75268);
  assert(mult_int(4, 18818) == 75272);
  assert(mult_int(4, 18819) == 75276);
  assert(mult_int(4, 18820) == 75280);
  assert(mult_int(4, 20736) == 82944);
  assert(mult_int(4, 21165) == 84660);
  assert(mult_int(4, 21166) == 84664);
  assert(mult_int(4, 21167) == 84668);
  assert(mult_int(4, 21168) == 84672);
  assert(mult_int(4, 21169) == 84676);
  assert(mult_int(4, 21170) == 84680);
  assert(mult_int(4, 21173) == 84692);
  assert(mult_int(4, 21174) == 84696);
  assert(mult_int(4, 21175) == 84700);
  assert(mult_int(4, 21176) == 84704);
  assert(mult_int(4, 21177) == 84708);
  assert(mult_int(4, 21178) == 84712);
  assert(mult_int(4, 21179) == 84716);
  assert(mult_int(4, 21180) == 84720);
  assert(mult_int(4, 21181) == 84724);
  assert(mult_int(4, 21182) == 84728);
  assert(mult_int(4, 21183) == 84732);
  assert(mult_int(4, 21184) == 84736);
  assert(mult_int(4, 21185) == 84740);
  assert(mult_int(4, 21218) == 84872);
  assert(mult_int(4, 21219) == 84876);
  assert(mult_int(4, 21220) == 84880);
  assert(mult_int(4, 21221) == 84884);
  assert(mult_int(4, 21222) == 84888);
  assert(mult_int(4, 21223) == 84892);
  assert(mult_int(4, 21224) == 84896);
  assert(mult_int(4, 21225) == 84900);
  assert(mult_int(4, 21226) == 84904);
  assert(mult_int(4, 21227) == 84908);
  assert(mult_int(4, 21228) == 84912);
  assert(mult_int(4, 21229) == 84916);
  assert(mult_int(4, 21230) == 84920);
  assert(mult_int(4, 21231) == 84924);
  assert(mult_int(4, 21337) == 85348);
  assert(mult_int(4, 21338) == 85352);
  assert(mult_int(4, 21339) == 85356);
  assert(mult_int(4, 21340) == 85360);
  assert(mult_int(4, 21341) == 85364);
  assert(mult_int(4, 21342) == 85368);
  assert(mult_int(4, 21343) == 85372);
  assert(mult_int(4, 21344) == 85376);
  assert(mult_int(4, 21345) == 85380);
  assert(mult_int(4, 21346) == 85384);
  assert(mult_int(4, 21347) == 85388);
  assert(mult_int(4, 21348) == 85392);
  assert(mult_int(4, 21349) == 85396);
  assert(mult_int(4, 21350) == 85400);
  assert(mult_int(4, 21351) == 85404);
  assert(mult_int(4, 21352) == 85408);
  assert(mult_int(4, 21353) == 85412);
  assert(mult_int(4, 21354) == 85416);
  assert(mult_int(4, 21355) == 85420);
  assert(mult_int(4, 21356) == 85424);
  assert(mult_int(4, 21357) == 85428);
  assert(mult_int(4, 21358) == 85432);
  assert(mult_int(4, 21359) == 85436);
  assert(mult_int(4, 21360) == 85440);
  assert(mult_int(4, 21361) == 85444);
  assert(mult_int(4, 21362) == 85448);
  assert(mult_int(4, 21363) == 85452);
  assert(mult_int(4, 21364) == 85456);
  assert(mult_int(4, 21365) == 85460);
  assert(mult_int(4, 21366) == 85464);
  assert(mult_int(4, 21367) == 85468);
  assert(mult_int(4, 21368) == 85472);
  assert(mult_int(4, 21369) == 85476);
  assert(mult_int(4, 21370) == 85480);
  assert(mult_int(4, 21371) == 85484);
  assert(mult_int(4, 21372) == 85488);
  assert(mult_int(4, 21373) == 85492);
  assert(mult_int(4, 21374) == 85496);
  assert(mult_int(4, 21375) == 85500);
  assert(mult_int(4, 21376) == 85504);
  assert(mult_int(4, 21377) == 85508);
  assert(mult_int(4, 21378) == 85512);
  assert(mult_int(4, 22672) == 90688);
  assert(mult_int(4, 22673) == 90692);
  assert(mult_int(4, 22724) == 90896);
  assert(mult_int(4, 22725) == 90900);
  assert(mult_int(4, 22726) == 90904);
  assert(mult_int(4, 22727) == 90908);
  assert(mult_int(4, 22728) == 90912);
  assert(mult_int(4, 22729) == 90916);
  assert(mult_int(4, 22730) == 90920);
  assert(mult_int(4, 22731) == 90924);
  assert(mult_int(4, 22732) == 90928);
  assert(mult_int(4, 22733) == 90932);
  assert(mult_int(4, 22746) == 90984);
  assert(mult_int(4, 22747) == 90988);
  assert(mult_int(4, 22753) == 91012);
  assert(mult_int(4, 22768) == 91072);
  assert(mult_int(4, 22769) == 91076);
  assert(mult_int(4, 22772) == 91088);
  assert(mult_int(4, 22773) == 91092);
  assert(mult_int(4, 22776) == 91104);
  assert(mult_int(4, 22777) == 91108);
  assert(mult_int(4, 22780) == 91120);
  assert(mult_int(4, 22781) == 91124);
  assert(mult_int(4, 22782) == 91128);
  assert(mult_int(4, 22783) == 91132);
  assert(mult_int(4, 22784) == 91136);
  assert(mult_int(4, 22785) == 91140);
  assert(mult_int(4, 22786) == 91144);
  assert(mult_int(4, 22787) == 91148);
  assert(mult_int(4, 22792) == 91168);
  assert(mult_int(4, 22793) == 91172);
  assert(mult_int(4, 22794) == 91176);
  assert(mult_int(4, 22795) == 91180);
  assert(mult_int(4, 22803) == 91212);
  assert(mult_int(4, 22804) == 91216);
  assert(mult_int(4, 22807) == 91228);
  assert(mult_int(4, 22808) == 91232);
  assert(mult_int(4, 22809) == 91236);
  assert(mult_int(4, 22813) == 91252);
  assert(mult_int(4, 22814) == 91256);
  assert(mult_int(4, 22815) == 91260);
  assert(mult_int(4, 22816) == 91264);
  assert(mult_int(4, 22817) == 91268);
  assert(mult_int(4, 22818) == 91272);
  assert(mult_int(4, 22819) == 91276);
  assert(mult_int(4, 22820) == 91280);
  assert(mult_int(4, 22821) == 91284);
  assert(mult_int(4, 22822) == 91288);
  assert(mult_int(4, 22823) == 91292);
  assert(mult_int(4, 22824) == 91296);
  assert(mult_int(4, 22825) == 91300);
  assert(mult_int(4, 22826) == 91304);
  assert(mult_int(4, 22827) == 91308);
  assert(mult_int(4, 22828) == 91312);
  assert(mult_int(4, 22829) == 91316);
  assert(mult_int(4, 22830) == 91320);
  assert(mult_int(4, 22837) == 91348);
  assert(mult_int(4, 22838) == 91352);
  assert(mult_int(4, 22839) == 91356);
  assert(mult_int(4, 22840) == 91360);
  assert(mult_int(4, 22852) == 91408);
  assert(mult_int(4, 22853) == 91412);
  assert(mult_int(4, 22854) == 91416);
  assert(mult_int(4, 22855) == 91420);
  assert(mult_int(4, 22858) == 91432);
  assert(mult_int(4, 22859) == 91436);
  assert(mult_int(4, 22884) == 91536);
  assert(mult_int(4, 22885) == 91540);
  assert(mult_int(4, 22886) == 91544);
  assert(mult_int(4, 22893) == 91572);
  assert(mult_int(4, 22894) == 91576);
  assert(mult_int(4, 22895) == 91580);
  assert(mult_int(4, 22898) == 91592);
  assert(mult_int(4, 22899) == 91596);
  assert(mult_int(4, 22900) == 91600);
  assert(mult_int(4, 22904) == 91616);
  assert(mult_int(4, 22905) == 91620);
  assert(mult_int(4, 22906) == 91624);
  assert(mult_int(4, 22907) == 91628);
  assert(mult_int(4, 22908) == 91632);
  assert(mult_int(4, 22909) == 91636);
  assert(mult_int(4, 22910) == 91640);
  assert(mult_int(4, 22911) == 91644);
  assert(mult_int(4, 22912) == 91648);
  assert(mult_int(4, 22915) == 91660);
  assert(mult_int(4, 22916) == 91664);
  assert(mult_int(4, 22917) == 91668);
  assert(mult_int(4, 22927) == 91708);
  assert(mult_int(4, 22928) == 91712);
  assert(mult_int(4, 22929) == 91716);
  assert(mult_int(4, 22930) == 91720);
  assert(mult_int(4, 22931) == 91724);
  assert(mult_int(4, 22932) == 91728);
  assert(mult_int(4, 22933) == 91732);
  assert(mult_int(4, 22934) == 91736);
  assert(mult_int(4, 22935) == 91740);
  assert(mult_int(4, 22938) == 91752);
  assert(mult_int(4, 22939) == 91756);
  assert(mult_int(4, 22942) == 91768);
  assert(mult_int(4, 22943) == 91772);
  assert(mult_int(4, 22944) == 91776);
  assert(mult_int(4, 22945) == 91780);
  assert(mult_int(4, 22952) == 91808);
  assert(mult_int(4, 22953) == 91812);
  assert(mult_int(4, 22954) == 91816);
  assert(mult_int(4, 22955) == 91820);
  assert(mult_int(4, 22956) == 91824);
  assert(mult_int(4, 22957) == 91828);
  assert(mult_int(4, 25712660) == 102850640);
  assert(mult_int(4, 25712661) == 102850644);
  assert(mult_int(4, 25712662) == 102850648);
  assert(mult_int(4, 25712663) == 102850652);
  assert(mult_int(4, 263168) == 1052672);
  assert(mult_int(4, 263169) == 1052676);
  assert(mult_int(4, 263170) == 1052680);
  assert(mult_int(4, 263171) == 1052684);
  assert(mult_int(4, 263172) == 1052688);
  assert(mult_int(4, 263173) == 1052692);
  assert(mult_int(4, 263174) == 1052696);
  assert(mult_int(4, 263175) == 1052700);
  assert(mult_int(4, 263176) == 1052704);
  assert(mult_int(4, 263177) == 1052708);
  assert(mult_int(4, 263178) == 1052712);
  assert(mult_int(4, 263179) == 1052716);
  assert(mult_int(4, 263180) == 1052720);
  assert(mult_int(4, 263181) == 1052724);
  assert(mult_int(4, 263182) == 1052728);
  assert(mult_int(4, 263183) == 1052732);
  assert(mult_int(4, 263184) == 1052736);
  assert(mult_int(4, 263185) == 1052740);
  assert(mult_int(4, 263186) == 1052744);
  assert(mult_int(4, 263187) == 1052748);
  assert(mult_int(4, 263188) == 1052752);
  assert(mult_int(4, 263189) == 1052756);
  assert(mult_int(4, 263190) == 1052760);
  assert(mult_int(4, 263191) == 1052764);
  assert(mult_int(4, 263192) == 1052768);
  assert(mult_int(4, 263193) == 1052772);
  assert(mult_int(4, 263194) == 1052776);
  assert(mult_int(4, 263195) == 1052780);
  assert(mult_int(4, 263196) == 1052784);
  assert(mult_int(4, 263197) == 1052788);
  assert(mult_int(4, 263198) == 1052792);
  assert(mult_int(4, 263199) == 1052796);
  assert(mult_int(4, 263200) == 1052800);
  assert(mult_int(4, 263202) == 1052808);
  assert(mult_int(4, 263203) == 1052812);
  assert(mult_int(4, 263204) == 1052816);
  assert(mult_int(4, 263205) == 1052820);
  assert(mult_int(4, 263206) == 1052824);
  assert(mult_int(4, 263207) == 1052828);
  assert(mult_int(4, 263208) == 1052832);
  assert(mult_int(4, 263211) == 1052844);
  assert(mult_int(4, 263212) == 1052848);
  assert(mult_int(4, 263213) == 1052852);
  assert(mult_int(4, 263214) == 1052856);
  assert(mult_int(4, 263216) == 1052864);
  assert(mult_int(4, 263217) == 1052868);
  assert(mult_int(4, 263218) == 1052872);
  assert(mult_int(4, 263219) == 1052876);
  assert(mult_int(4, 263220) == 1052880);
  assert(mult_int(4, 263221) == 1052884);
  assert(mult_int(4, 263222) == 1052888);
  assert(mult_int(4, 263223) == 1052892);
  assert(mult_int(4, 263224) == 1052896);
  assert(mult_int(4, 263225) == 1052900);
  assert(mult_int(4, 263226) == 1052904);
  assert(mult_int(4, 263227) == 1052908);
  assert(mult_int(4, 263228) == 1052912);
  assert(mult_int(4, 263229) == 1052916);
  assert(mult_int(4, 263230) == 1052920);
  assert(mult_int(4, 263231) == 1052924);
  assert(mult_int(4, 263232) == 1052928);
  assert(mult_int(4, 263233) == 1052932);
  assert(mult_int(4, 263234) == 1052936);
  assert(mult_int(4, 263235) == 1052940);
  assert(mult_int(4, 263236) == 1052944);
  assert(mult_int(4, 263237) == 1052948);
  assert(mult_int(4, 263238) == 1052952);
  assert(mult_int(4, 263239) == 1052956);
  assert(mult_int(4, 263240) == 1052960);
  assert(mult_int(4, 263241) == 1052964);
  assert(mult_int(4, 263242) == 1052968);
  assert(mult_int(4, 263243) == 1052972);
  assert(mult_int(4, 263244) == 1052976);
  assert(mult_int(4, 263245) == 1052980);
  assert(mult_int(4, 263246) == 1052984);
  assert(mult_int(4, 263247) == 1052988);
  assert(mult_int(4, 263248) == 1052992);
  assert(mult_int(4, 263249) == 1052996);
  assert(mult_int(4, 263250) == 1053000);
  assert(mult_int(4, 263251) == 1053004);
  assert(mult_int(4, 263252) == 1053008);
  assert(mult_int(4, 263253) == 1053012);
  assert(mult_int(4, 263254) == 1053016);
  assert(mult_int(4, 263255) == 1053020);
  assert(mult_int(4, 263256) == 1053024);
  assert(mult_int(4, 263257) == 1053028);
  assert(mult_int(4, 263258) == 1053032);
  assert(mult_int(4, 263259) == 1053036);
  assert(mult_int(4, 263260) == 1053040);
  assert(mult_int(4, 263261) == 1053044);
  assert(mult_int(4, 263262) == 1053048);
  assert(mult_int(4, 263263) == 1053052);
  assert(mult_int(4, 263264) == 1053056);
  assert(mult_int(4, 263265) == 1053060);
  assert(mult_int(4, 263266) == 1053064);
  assert(mult_int(4, 263267) == 1053068);
  assert(mult_int(4, 263268) == 1053072);
  assert(mult_int(4, 263269) == 1053076);
  assert(mult_int(4, 263270) == 1053080);
  assert(mult_int(4, 263271) == 1053084);
  assert(mult_int(4, 263272) == 1053088);
  assert(mult_int(4, 263273) == 1053092);
  assert(mult_int(4, 263274) == 1053096);
  assert(mult_int(4, 263275) == 1053100);
  assert(mult_int(4, 263276) == 1053104);
  assert(mult_int(4, 263277) == 1053108);
  assert(mult_int(4, 263278) == 1053112);
  assert(mult_int(4, 263296) == 1053184);
  assert(mult_int(4, 263297) == 1053188);
  assert(mult_int(4, 263298) == 1053192);
  assert(mult_int(4, 263299) == 1053196);
  assert(mult_int(4, 263300) == 1053200);
  assert(mult_int(4, 263301) == 1053204);
  assert(mult_int(4, 263302) == 1053208);
  assert(mult_int(4, 263303) == 1053212);
  assert(mult_int(4, 264192) == 1056768);
  assert(mult_int(4, 264193) == 1056772);
  assert(mult_int(4, 264194) == 1056776);
  assert(mult_int(4, 264195) == 1056780);
  assert(mult_int(4, 264196) == 1056784);
  assert(mult_int(4, 264197) == 1056788);
  assert(mult_int(4, 264198) == 1056792);
  assert(mult_int(4, 264199) == 1056796);
  assert(mult_int(4, 264200) == 1056800);
  assert(mult_int(4, 264201) == 1056804);
  assert(mult_int(4, 264202) == 1056808);
  assert(mult_int(4, 264203) == 1056812);
  assert(mult_int(4, 264204) == 1056816);
  assert(mult_int(4, 264205) == 1056820);
  assert(mult_int(4, 264206) == 1056824);
  assert(mult_int(4, 264207) == 1056828);
  assert(mult_int(4, 264208) == 1056832);
  assert(mult_int(4, 264209) == 1056836);
  assert(mult_int(4, 264210) == 1056840);
  assert(mult_int(4, 264211) == 1056844);
  assert(mult_int(4, 264212) == 1056848);
  assert(mult_int(4, 264213) == 1056852);
  assert(mult_int(4, 264214) == 1056856);
  assert(mult_int(4, 264215) == 1056860);
  assert(mult_int(4, 264216) == 1056864);
  assert(mult_int(4, 264217) == 1056868);
  assert(mult_int(4, 264218) == 1056872);
  assert(mult_int(4, 264219) == 1056876);
  assert(mult_int(4, 264220) == 1056880);
  assert(mult_int(4, 264221) == 1056884);
  assert(mult_int(4, 264222) == 1056888);
  assert(mult_int(4, 264223) == 1056892);
  assert(mult_int(4, 264224) == 1056896);
  assert(mult_int(4, 264225) == 1056900);
  assert(mult_int(4, 264226) == 1056904);
  assert(mult_int(4, 264227) == 1056908);
  assert(mult_int(4, 264228) == 1056912);
  assert(mult_int(4, 264230) == 1056920);
  assert(mult_int(4, 264231) == 1056924);
  assert(mult_int(4, 264232) == 1056928);
  assert(mult_int(4, 264233) == 1056932);
  assert(mult_int(4, 264234) == 1056936);
  assert(mult_int(4, 264235) == 1056940);
  assert(mult_int(4, 264236) == 1056944);
  assert(mult_int(4, 264239) == 1056956);
  assert(mult_int(4, 264240) == 1056960);
  assert(mult_int(4, 264241) == 1056964);
  assert(mult_int(4, 264242) == 1056968);
  assert(mult_int(4, 264244) == 1056976);
  assert(mult_int(4, 264245) == 1056980);
  assert(mult_int(4, 264246) == 1056984);
  assert(mult_int(4, 264247) == 1056988);
  assert(mult_int(4, 264248) == 1056992);
  assert(mult_int(4, 264249) == 1056996);
  assert(mult_int(4, 264250) == 1057000);
  assert(mult_int(4, 264251) == 1057004);
  assert(mult_int(4, 264252) == 1057008);
  assert(mult_int(4, 264253) == 1057012);
  assert(mult_int(4, 264254) == 1057016);
  assert(mult_int(4, 264255) == 1057020);
  assert(mult_int(4, 264256) == 1057024);
  assert(mult_int(4, 264257) == 1057028);
  assert(mult_int(4, 264258) == 1057032);
  assert(mult_int(4, 264259) == 1057036);
  assert(mult_int(4, 264260) == 1057040);
  assert(mult_int(4, 264261) == 1057044);
  assert(mult_int(4, 264262) == 1057048);
  assert(mult_int(4, 264263) == 1057052);
  assert(mult_int(4, 264264) == 1057056);
  assert(mult_int(4, 264265) == 1057060);
  assert(mult_int(4, 264266) == 1057064);
  assert(mult_int(4, 264267) == 1057068);
  assert(mult_int(4, 264268) == 1057072);
  assert(mult_int(4, 264269) == 1057076);
  assert(mult_int(4, 264270) == 1057080);
  assert(mult_int(4, 264271) == 1057084);
  assert(mult_int(4, 264272) == 1057088);
  assert(mult_int(4, 264273) == 1057092);
  assert(mult_int(4, 264274) == 1057096);
  assert(mult_int(4, 264275) == 1057100);
  assert(mult_int(4, 264276) == 1057104);
  assert(mult_int(4, 264277) == 1057108);
  assert(mult_int(4, 264278) == 1057112);
  assert(mult_int(4, 264279) == 1057116);
  assert(mult_int(4, 264280) == 1057120);
  assert(mult_int(4, 264281) == 1057124);
  assert(mult_int(4, 264282) == 1057128);
  assert(mult_int(4, 264283) == 1057132);
  assert(mult_int(4, 264284) == 1057136);
  assert(mult_int(4, 264285) == 1057140);
  assert(mult_int(4, 264286) == 1057144);
  assert(mult_int(4, 264287) == 1057148);
  assert(mult_int(4, 264288) == 1057152);
  assert(mult_int(4, 264289) == 1057156);
  assert(mult_int(4, 264290) == 1057160);
  assert(mult_int(4, 264291) == 1057164);
  assert(mult_int(4, 264292) == 1057168);
  assert(mult_int(4, 264293) == 1057172);
  assert(mult_int(4, 264294) == 1057176);
  assert(mult_int(4, 264295) == 1057180);
  assert(mult_int(4, 264296) == 1057184);
  assert(mult_int(4, 264297) == 1057188);
  assert(mult_int(4, 264298) == 1057192);
  assert(mult_int(4, 264299) == 1057196);
  assert(mult_int(4, 264300) == 1057200);
  assert(mult_int(4, 27197) == 108788);
  assert(mult_int(4, 27198) == 108792);
  assert(mult_int(4, 27199) == 108796);
  assert(mult_int(4, 27200) == 108800);
  assert(mult_int(4, 27201) == 108804);
  assert(mult_int(4, 27202) == 108808);
  assert(mult_int(4, 27203) == 108812);
  assert(mult_int(4, 27204) == 108816);
  assert(mult_int(4, 27205) == 108820);
  assert(mult_int(4, 27206) == 108824);
  assert(mult_int(4, 27207) == 108828);
  assert(mult_int(4, 27208) == 108832);
  assert(mult_int(4, 27209) == 108836);
  assert(mult_int(4, 27210) == 108840);
  assert(mult_int(4, 27211) == 108844);
  assert(mult_int(4, 27212) == 108848);
  assert(mult_int(4, 38273058) == 153092232);
  assert(mult_int(4, 38273059) == 153092236);
  assert(mult_int(4, 4194304) == 16777216);
  assert(mult_int(4, 4194305) == 16777220);
  assert(mult_int(4, 4194306) == 16777224);
  assert(mult_int(4, 4194307) == 16777228);
  assert(mult_int(4, 4194308) == 16777232);
  assert(mult_int(4, 4194309) == 16777236);
  assert(mult_int(4, 4194310) == 16777240);
  assert(mult_int(4, 4194311) == 16777244);
  assert(mult_int(4, 4194312) == 16777248);
  assert(mult_int(4, 4194313) == 16777252);
  assert(mult_int(4, 4194314) == 16777256);
  assert(mult_int(4, 4194315) == 16777260);
  assert(mult_int(4, 4194316) == 16777264);
  assert(mult_int(4, 4194317) == 16777268);
  assert(mult_int(8, 14187) == 113496);
  assert(mult_int(8, 14188) == 113504);
  assert(mult_int(8, 14197) == 113576);
  assert(mult_int(8, 14318) == 114544);
  assert(mult_int(8, 14329) == 114632);
  assert(mult_int(8, 14505) == 116040);
  assert(mult_int(8, 14506) == 116048);
  assert(mult_int(8, 14507) == 116056);
  assert(mult_int(8, 14508) == 116064);
  assert(mult_int(8, 14509) == 116072);
  assert(mult_int(8, 14510) == 116080);
  assert(mult_int(8, 14511) == 116088);
  assert(mult_int(8, 14512) == 116096);
  assert(mult_int(8, 14515) == 116120);
  assert(mult_int(8, 14516) == 116128);
  assert(mult_int(8, 14517) == 116136);
  assert(mult_int(8, 6029845) == 48238760);
  assert(mult_int(8, 6029846) == 48238768);
  assert(mult_int(8, 6029847) == 48238776);
  assert(mult_int(8, 6029848) == 48238784);
  assert(mult_int(8, 6029849) == 48238792);
  assert(mult_int(8, 6029850) == 48238800);
  assert(mult_int(8, 6029851) == 48238808);
  assert(mult_int(8, 6029852) == 48238816);
  assert(mult_int(8, 6029853) == 48238824);
  assert(mult_int(8, 6029854) == 48238832);
  assert(mult_int(8, 6029855) == 48238840);
  assert(mult_int(8, 6029856) == 48238848);
  assert(mult_int(8, 6029857) == 48238856);
  assert(mult_int(8, 6029858) == 48238864);
  assert(mult_int(8, 6029859) == 48238872);
  assert(mult_int(8, 6029860) == 48238880);
  assert(mult_int(8, 6029861) == 48238888);
  assert(mult_int(8, 6029862) == 48238896);
  assert(mult_int(8, 6029863) == 48238904);
  assert(mult_int(8, 6029864) == 48238912);
  assert(mult_int(8, 6029865) == 48238920);
  assert(mult_int(8, 6029866) == 48238928);
  assert(mult_int(8, 6029867) == 48238936);
  assert(mult_int(8, 6029868) == 48238944);
  assert(mult_int(8, 6029869) == 48238952);
  assert(mult_int(8, 6029870) == 48238960);
  assert(mult_int(8, 6029871) == 48238968);
  assert(mult_int(8, 6029872) == 48238976);
  assert(mult_int(8, 6029873) == 48238984);
  assert(mult_int(8, 6029874) == 48238992);
  assert(mult_int(8, 6029875) == 48239000);
  assert(mult_int(8, 6029876) == 48239008);
  assert(mult_int(8, 6029877) == 48239016);
  assert(mult_int(8, 6029878) == 48239024);
  assert(mult_int(8, 6029879) == 48239032);
  assert(mult_int(8, 6029880) == 48239040);
  assert(mult_int(8, 6029881) == 48239048);
  assert(mult_int(8, 6029882) == 48239056);
  assert(mult_int(8, 6029883) == 48239064);
  assert(mult_int(8, 6029884) == 48239072);
  assert(mult_int(8, 6029885) == 48239080);
  assert(mult_int(8, 6029886) == 48239088);
  assert(mult_int(8, 6029887) == 48239096);
  assert(mult_int(8, 6029888) == 48239104);
  assert(mult_int(8, 6029889) == 48239112);
  assert(mult_int(8, 6029890) == 48239120);
  assert(mult_int(8, 6029891) == 48239128);
  assert(mult_int(8, 6029892) == 48239136);
  assert(mult_int(8, 6029893) == 48239144);
  assert(mult_int(8, 6029894) == 48239152);
  assert(mult_int(8, 6029895) == 48239160);
  assert(mult_int(8, 6029896) == 48239168);
  assert(mult_int(8, 6029897) == 48239176);
  assert(mult_int(8, 6029898) == 48239184);
  assert(mult_int(8, 6029899) == 48239192);
  assert(mult_int(8, 6029900) == 48239200);
  assert(mult_int(8, 6029901) == 48239208);
  assert(mult_int(8, 6029902) == 48239216);
  assert(mult_int(8, 6029903) == 48239224);
  assert(mult_int(8, 6029904) == 48239232);
  assert(mult_int(8, 6029905) == 48239240);
  assert(mult_int(8, 6029906) == 48239248);
  assert(mult_int(8, 6029907) == 48239256);
  assert(mult_int(8, 6029908) == 48239264);
  assert(mult_int(8, 6029909) == 48239272);
  assert(mult_int(8, 6029910) == 48239280);
  assert(mult_int(8, 6029911) == 48239288);
  assert(mult_int(8, 6029912) == 48239296);
  assert(mult_int(8, 6029913) == 48239304);
  assert(mult_int(8, 6029914) == 48239312);
  assert(mult_int(8, 6029915) == 48239320);
  assert(mult_int(8, 6029916) == 48239328);
  assert(mult_int(8, 6029917) == 48239336);
  assert(mult_int(8, 6029918) == 48239344);
  assert(mult_int(8, 6029919) == 48239352);
  assert(mult_int(8, 6029920) == 48239360);
  assert(mult_int(8, 6029921) == 48239368);
  assert(mult_int(8, 6029922) == 48239376);
  assert(mult_int(8, 6029923) == 48239384);
  assert(mult_int(8, 6029924) == 48239392);
  assert(mult_int(8, 6029925) == 48239400);
  assert(mult_int(8, 6029926) == 48239408);
  assert(mult_int(8, 6029927) == 48239416);
  assert(mult_int(8, 6029928) == 48239424);
  assert(mult_int(8, 6029929) == 48239432);
  assert(mult_int(8, 6029930) == 48239440);
  assert(mult_int(8, 6029931) == 48239448);
  assert(mult_int(8, 6029932) == 48239456);
  assert(mult_int(8, 6029933) == 48239464);
  assert(mult_int(8, 6029934) == 48239472);
  assert(mult_int(8, 6029935) == 48239480);
  assert(mult_int(8, 6029936) == 48239488);
  assert(mult_int(8, 6029937) == 48239496);
  assert(mult_int(8, 6029938) == 48239504);
  assert(mult_int(8, 6029939) == 48239512);
  assert(mult_int(8, 6029940) == 48239520);
  assert(mult_int(8, 6029941) == 48239528);
  assert(mult_int(8, 6029942) == 48239536);
  assert(mult_int(8, 6029943) == 48239544);
  assert(mult_int(8, 6029944) == 48239552);
  assert(mult_int(8, 6029945) == 48239560);
  assert(mult_int(8, 6029946) == 48239568);
  assert(mult_int(8, 6029947) == 48239576);
  assert(mult_int(8, 6029948) == 48239584);
  assert(mult_int(8, 6029949) == 48239592);
  assert(mult_int(8, 6029950) == 48239600);
  assert(mult_int(8, 6029951) == 48239608);
  assert(mult_int(8, 6029952) == 48239616);
  assert(mult_int(8, 6029953) == 48239624);
  assert(mult_int(8, 6029954) == 48239632);
  assert(mult_int(8, 6029955) == 48239640);
  assert(mult_int(8, 6029956) == 48239648);
  assert(mult_int(8, 6029957) == 48239656);
  assert(mult_int(8, 6029958) == 48239664);
  assert(mult_int(8, 6029959) == 48239672);
  assert(mult_int(8, 6029960) == 48239680);
  assert(mult_int(8, 6029961) == 48239688);
  assert(mult_int(8, 6029962) == 48239696);
  assert(mult_int(8, 6029963) == 48239704);
  assert(mult_int(8, 6029964) == 48239712);
  assert(mult_int(8, 6029965) == 48239720);
  assert(mult_int(8, 6029966) == 48239728);
  assert(mult_int(8, 6029967) == 48239736);
  assert(mult_int(8, 6029968) == 48239744);
  assert(mult_int(8, 6029969) == 48239752);
  assert(mult_int(8, 6029970) == 48239760);
  assert(mult_int(8, 6029971) == 48239768);
  assert(mult_int(8, 6029972) == 48239776);
  assert(mult_int(8, 6029973) == 48239784);
  assert(mult_int(8, 6029974) == 48239792);
  assert(mult_int(8, 6029975) == 48239800);
  assert(mult_int(8, 6029976) == 48239808);
  assert(mult_int(8, 6029977) == 48239816);
  assert(mult_int(8, 6029978) == 48239824);
  assert(mult_int(8, 6029979) == 48239832);
  assert(mult_int(8, 6029980) == 48239840);
  assert(mult_int(8, 6029981) == 48239848);
  assert(mult_int(8, 6029982) == 48239856);
  assert(mult_int(8, 6029983) == 48239864);
  assert(mult_int(8, 6029984) == 48239872);
  assert(mult_int(8, 6029985) == 48239880);
  assert(mult_int(8, 6029986) == 48239888);
  assert(mult_int(8, 6029987) == 48239896);
  assert(mult_int(8, 6029988) == 48239904);
  assert(mult_int(8, 6029989) == 48239912);
  assert(mult_int(8, 6029990) == 48239920);
  assert(mult_int(8, 6029991) == 48239928);
  assert(mult_int(8, 6029992) == 48239936);
  assert(mult_int(8, 6029993) == 48239944);
  assert(mult_int(8, 6029994) == 48239952);
  assert(mult_int(8, 6029995) == 48239960);
  assert(mult_int(8, 6029996) == 48239968);
  assert(mult_int(8, 6029997) == 48239976);
  assert(mult_int(8, 6029998) == 48239984);
  assert(mult_int(8, 6029999) == 48239992);
  assert(mult_int(8, 6030000) == 48240000);
  assert(mult_int(8, 6030001) == 48240008);
  assert(mult_int(8, 6030002) == 48240016);
  assert(mult_int(8, 6030003) == 48240024);
  assert(mult_int(8, 6030004) == 48240032);
  assert(mult_int(8, 6030005) == 48240040);
  assert(mult_int(8, 6030006) == 48240048);
  assert(mult_int(8, 6030007) == 48240056);
  assert(mult_int(8, 6030008) == 48240064);
  assert(mult_int(8, 6030009) == 48240072);
  assert(mult_int(8, 6030010) == 48240080);
  assert(mult_int(8, 6030011) == 48240088);
  assert(mult_int(8, 6030012) == 48240096);
  assert(mult_int(8, 6030013) == 48240104);
  assert(mult_int(8, 6030014) == 48240112);
  assert(mult_int(8, 6030015) == 48240120);
  assert(mult_int(8, 6030016) == 48240128);
  assert(mult_int(8, 6030017) == 48240136);
  assert(mult_int(8, 6030018) == 48240144);
  assert(mult_int(8, 6030019) == 48240152);
  assert(mult_int(8, 6030020) == 48240160);
  assert(mult_int(8, 6030021) == 48240168);
  assert(mult_int(8, 6030022) == 48240176);
  assert(mult_int(8, 6030023) == 48240184);
  assert(mult_int(8, 6030024) == 48240192);
  assert(mult_int(8, 6030025) == 48240200);
  assert(mult_int(8, 6030026) == 48240208);
  assert(mult_int(8, 6030027) == 48240216);
  assert(mult_int(8, 6030028) == 48240224);
  assert(mult_int(8, 6030029) == 48240232);
  assert(mult_int(8, 6030030) == 48240240);
  assert(mult_int(8, 6030031) == 48240248);
  assert(mult_int(8, 6030032) == 48240256);
  assert(mult_int(8, 6030033) == 48240264);
  assert(mult_int(8, 6030034) == 48240272);
  assert(mult_int(8, 6030035) == 48240280);
  assert(mult_int(8, 6030036) == 48240288);
  assert(mult_int(8, 6030037) == 48240296);
  assert(mult_int(8, 6030038) == 48240304);
  assert(mult_int(8, 6030039) == 48240312);
  assert(mult_int(8, 6030040) == 48240320);
  assert(mult_int(8, 6030041) == 48240328);
  assert(mult_int(8, 6030042) == 48240336);
  assert(mult_int(8, 6030043) == 48240344);
  assert(mult_int(8, 6030044) == 48240352);
  assert(mult_int(8, 6030045) == 48240360);
  assert(mult_int(8, 6030046) == 48240368);
  assert(mult_int(8, 6030047) == 48240376);
  assert(mult_int(8, 6030048) == 48240384);
  assert(mult_int(8, 6030049) == 48240392);
  assert(mult_int(8, 6030050) == 48240400);
  assert(mult_int(8, 6030051) == 48240408);
  assert(mult_int(8, 6030052) == 48240416);
  assert(mult_int(8, 6030053) == 48240424);
  assert(mult_int(8, 6030054) == 48240432);
  assert(mult_int(8, 6030055) == 48240440);
  assert(mult_int(8, 6030056) == 48240448);
  assert(mult_int(8, 6030057) == 48240456);
  assert(mult_int(8, 6030058) == 48240464);
  assert(mult_int(8, 6030059) == 48240472);
  assert(mult_int(8, 6030060) == 48240480);
  assert(mult_int(8, 6030061) == 48240488);
  assert(mult_int(8, 6030062) == 48240496);
  assert(mult_int(8, 6030063) == 48240504);
  assert(mult_int(8, 6030064) == 48240512);
  assert(mult_int(8, 6030065) == 48240520);
  assert(mult_int(8, 6030066) == 48240528);
  assert(mult_int(8, 6030067) == 48240536);
  assert(mult_int(8, 6030068) == 48240544);
  assert(mult_int(8, 6030069) == 48240552);
  assert(mult_int(8, 6030070) == 48240560);
  assert(mult_int(8, 6030071) == 48240568);
  assert(mult_int(8, 6030072) == 48240576);
  assert(mult_int(8, 6030073) == 48240584);
  assert(mult_int(8, 6030074) == 48240592);
  assert(mult_int(8, 6030075) == 48240600);
  assert(mult_int(8, 6030076) == 48240608);
  assert(mult_int(8, 6030077) == 48240616);
  assert(mult_int(8, 6030078) == 48240624);
  assert(mult_int(8, 6030079) == 48240632);
  assert(mult_int(8, 6030080) == 48240640);
  assert(mult_int(8, 6030081) == 48240648);
  assert(mult_int(8, 6030082) == 48240656);
  assert(mult_int(8, 6030083) == 48240664);
  assert(mult_int(8, 6030084) == 48240672);
  assert(mult_int(8, 6030085) == 48240680);
  assert(mult_int(8, 6030086) == 48240688);
  assert(mult_int(8, 6030087) == 48240696);
  assert(mult_int(8, 6030088) == 48240704);
  assert(mult_int(8, 6030089) == 48240712);
  assert(mult_int(8, 6030090) == 48240720);
  assert(mult_int(8, 6030091) == 48240728);
  assert(mult_int(8, 6030092) == 48240736);
  assert(mult_int(8, 6030093) == 48240744);
  assert(mult_int(8, 6030094) == 48240752);
  assert(mult_int(8, 6030095) == 48240760);
  assert(mult_int(8, 6030096) == 48240768);
  assert(mult_int(8, 6030097) == 48240776);
  assert(mult_int(8, 6030098) == 48240784);
  assert(mult_int(8, 6030099) == 48240792);
  assert(mult_int(8, 6030100) == 48240800);
  assert(mult_int(8, 6030101) == 48240808);
  assert(mult_int(8, 6030102) == 48240816);
  assert(mult_int(8, 6030103) == 48240824);
  assert(mult_int(8, 6119424) == 48955392);
  assert(mult_int(8, 6127616) == 49020928);
  assert(mult_int(8, 6144000) == 49152000);
  assert(mult_int(8, 6152192) == 49217536);
  assert(mult_int(8, 6152200) == 49217600);
  assert(mult_int(8, 6160385) == 49283080);
  assert(mult_int(8, 6160386) == 49283088);
  assert(mult_int(8, 6160387) == 49283096);
  assert(mult_int(8, 6160388) == 49283104);
  assert(mult_int(8, 6160389) == 49283112);
  assert(mult_int(8, 6160390) == 49283120);
  assert(mult_int(8, 6160391) == 49283128);
  assert(mult_int(8, 6160392) == 49283136);
  assert(mult_int(8, 6160393) == 49283144);
  assert(mult_int(8, 6160394) == 49283152);
  assert(mult_int(8, 6160395) == 49283160);
  assert(mult_int(8, 6160396) == 49283168);
  assert(mult_int(8, 6160397) == 49283176);
  assert(mult_int(8, 6160398) == 49283184);
  assert(mult_int(8, 6160399) == 49283192);
  assert(mult_int(8, 6160400) == 49283200);
  assert(mult_int(8, 6160401) == 49283208);
  assert(mult_int(8, 6160402) == 49283216);
  assert(mult_int(8, 6160403) == 49283224);
  assert(mult_int(8, 6160404) == 49283232);
  assert(mult_int(8, 6160405) == 49283240);
  assert(mult_int(8, 6160406) == 49283248);
  assert(mult_int(8, 6160407) == 49283256);
  assert(mult_int(8, 6160408) == 49283264);
  assert(mult_int(8, 6160409) == 49283272);
  assert(mult_int(8, 6160410) == 49283280);
  assert(mult_int(8, 6160411) == 49283288);
  assert(mult_int(8, 6160412) == 49283296);
  assert(mult_int(8, 6160413) == 49283304);
  assert(mult_int(8, 6160414) == 49283312);
  assert(mult_int(8, 6160415) == 49283320);
  assert(mult_int(8, 6160416) == 49283328);
  assert(mult_int(8, 6160506) == 49284048);
  assert(mult_int(8, 6160507) == 49284056);
  assert(mult_int(8, 6160508) == 49284064);
  assert(mult_int(8, 6160509) == 49284072);
  assert(mult_int(8, 6160510) == 49284080);
  assert(mult_int(8, 6160511) == 49284088);
  assert(mult_int(8, 6160512) == 49284096);
  assert(mult_int(8, 6160513) == 49284104);
  assert(mult_int(8, 6160514) == 49284112);
  assert(mult_int(8, 6160515) == 49284120);
  assert(mult_int(8, 6160516) == 49284128);
  assert(mult_int(8, 6160517) == 49284136);
  assert(mult_int(8, 6160518) == 49284144);
  assert(mult_int(8, 6160519) == 49284152);
  assert(mult_int(8, 6160520) == 49284160);
  assert(mult_int(8, 6160521) == 49284168);
  assert(mult_int(8, 6160522) == 49284176);
  assert(mult_int(8, 6160523) == 49284184);
  assert(mult_int(8, 6160524) == 49284192);
  assert(mult_int(8, 6160525) == 49284200);
  assert(mult_int(8, 6160526) == 49284208);
  assert(mult_int(8, 6160527) == 49284216);
  assert(mult_int(8, 6160528) == 49284224);
  assert(mult_int(8, 6160529) == 49284232);
  assert(mult_int(8, 6160530) == 49284240);
  assert(mult_int(8, 6160531) == 49284248);
  assert(mult_int(8, 6160532) == 49284256);
  assert(mult_int(8, 6160533) == 49284264);
  assert(mult_int(8, 6160534) == 49284272);
  assert(mult_int(8, 6160535) == 49284280);
  assert(mult_int(8, 6160536) == 49284288);
  assert(mult_int(8, 6160537) == 49284296);
  assert(mult_int(8, 6160538) == 49284304);
  assert(mult_int(8, 6160539) == 49284312);
  assert(mult_int(8, 6160540) == 49284320);
  assert(mult_int(8, 6160541) == 49284328);
  assert(mult_int(8, 6160542) == 49284336);
  assert(mult_int(8, 6160543) == 49284344);
  assert(mult_int(8, 6160544) == 49284352);
  assert(mult_int(8, 6160545) == 49284360);
  assert(mult_int(8, 6160546) == 49284368);
  assert(mult_int(8, 6160547) == 49284376);
  assert(mult_int(8, 6160548) == 49284384);
  assert(mult_int(8, 6160549) == 49284392);
  assert(mult_int(8, 6160550) == 49284400);
  assert(mult_int(8, 6160551) == 49284408);
  assert(mult_int(8, 6160552) == 49284416);
  assert(mult_int(8, 6160553) == 49284424);
  assert(mult_int(8, 6160554) == 49284432);
  assert(mult_int(8, 6160555) == 49284440);
  assert(mult_int(8, 6160556) == 49284448);
  assert(mult_int(8, 6160557) == 49284456);
  assert(mult_int(8, 6160558) == 49284464);
  assert(mult_int(8, 6160559) == 49284472);
  assert(mult_int(8, 6160560) == 49284480);
  assert(mult_int(8, 6160561) == 49284488);
  assert(mult_int(8, 6160562) == 49284496);
  assert(mult_int(8, 6160563) == 49284504);
  assert(mult_int(8, 6160564) == 49284512);
  assert(mult_int(8, 6160565) == 49284520);
  assert(mult_int(8, 6160566) == 49284528);
  assert(mult_int(8, 6160567) == 49284536);
  assert(mult_int(8, 6160568) == 49284544);
  assert(mult_int(8, 6160569) == 49284552);
  assert(mult_int(8, 6160570) == 49284560);
  assert(mult_int(8, 6160571) == 49284568);
  assert(mult_int(8, 6160572) == 49284576);
  assert(mult_int(8, 6160573) == 49284584);
  assert(mult_int(8, 6160574) == 49284592);
  assert(mult_int(8, 6160575) == 49284600);
  assert(mult_int(8, 6160576) == 49284608);
  assert(mult_int(8, 6160577) == 49284616);
  assert(mult_int(8, 6160578) == 49284624);
  assert(mult_int(8, 6160579) == 49284632);
  assert(mult_int(8, 6160580) == 49284640);
  assert(mult_int(8, 6160581) == 49284648);
  assert(mult_int(8, 6160582) == 49284656);
  assert(mult_int(8, 6160583) == 49284664);
  assert(mult_int(8, 6160584) == 49284672);
  assert(mult_int(8, 6160585) == 49284680);
  assert(mult_int(8, 6160586) == 49284688);
  assert(mult_int(8, 6160587) == 49284696);
  assert(mult_int(8, 6160588) == 49284704);
  assert(mult_int(8, 6160589) == 49284712);
  assert(mult_int(8, 6160590) == 49284720);
  assert(mult_int(8, 6160591) == 49284728);
  assert(mult_int(8, 6160592) == 49284736);
  assert(mult_int(8, 6160593) == 49284744);
  assert(mult_int(8, 6160594) == 49284752);
  assert(mult_int(8, 6160595) == 49284760);
  assert(mult_int(8, 6160596) == 49284768);
  assert(mult_int(8, 6160597) == 49284776);
  assert(mult_int(8, 6160598) == 49284784);
  assert(mult_int(8, 6160599) == 49284792);
  assert(mult_int(8, 6160600) == 49284800);
  assert(mult_int(8, 6160601) == 49284808);
  assert(mult_int(8, 6160602) == 49284816);
  assert(mult_int(8, 6160603) == 49284824);
  assert(mult_int(8, 6160604) == 49284832);
  assert(mult_int(8, 6160605) == 49284840);
  assert(mult_int(8, 6160606) == 49284848);
  assert(mult_int(8, 6160607) == 49284856);
  assert(mult_int(8, 6160608) == 49284864);
  assert(mult_int(8, 6160609) == 49284872);
  assert(mult_int(8, 6160610) == 49284880);
  assert(mult_int(8, 6160611) == 49284888);
  assert(mult_int(8, 6160612) == 49284896);
  assert(mult_int(8, 6160613) == 49284904);
  assert(mult_int(8, 6160614) == 49284912);
  assert(mult_int(8, 6160615) == 49284920);
  assert(mult_int(8, 6160616) == 49284928);
  assert(mult_int(8, 6160617) == 49284936);
  assert(mult_int(8, 6160618) == 49284944);
  assert(mult_int(8, 6160619) == 49284952);
  assert(mult_int(8, 6160620) == 49284960);
  assert(mult_int(8, 6160621) == 49284968);
  assert(mult_int(8, 6160622) == 49284976);
  assert(mult_int(8, 6160623) == 49284984);
  assert(mult_int(8, 6160624) == 49284992);
  assert(mult_int(8, 6160625) == 49285000);
  assert(mult_int(8, 6160626) == 49285008);
  assert(mult_int(8, 6160627) == 49285016);
  assert(mult_int(8, 6160628) == 49285024);
  assert(mult_int(8, 6160629) == 49285032);
  assert(mult_int(8, 6160630) == 49285040);
  assert(mult_int(8, 6160631) == 49285048);
  assert(mult_int(8, 6160632) == 49285056);
  assert(mult_int(8, 6160633) == 49285064);
  assert(mult_int(8, 6160634) == 49285072);
  assert(mult_int(8, 6160635) == 49285080);
  assert(mult_int(8, 6160636) == 49285088);
  assert(mult_int(8, 6160637) == 49285096);
  assert(mult_int(8, 6160638) == 49285104);
  assert(mult_int(8, 6160639) == 49285112);
  assert(mult_int(8, 6160640) == 49285120);
  assert(mult_int(8, 6160641) == 49285128);
  assert(mult_int(8, 6160642) == 49285136);
  assert(mult_int(8, 6160643) == 49285144);
  assert(mult_int(8, 6160644) == 49285152);
  assert(mult_int(8, 6160645) == 49285160);
  assert(mult_int(8, 6160646) == 49285168);
  assert(mult_int(8, 6160647) == 49285176);
  assert(mult_int(8, 6160648) == 49285184);
  assert(mult_int(8, 6160649) == 49285192);
  assert(mult_int(8, 6160650) == 49285200);
  assert(mult_int(8, 6160651) == 49285208);
  assert(mult_int(8, 6160652) == 49285216);
  assert(mult_int(8, 6160653) == 49285224);
  assert(mult_int(8, 6160654) == 49285232);
  assert(mult_int(8, 6160655) == 49285240);
  assert(mult_int(8, 6160656) == 49285248);
  assert(mult_int(8, 6160657) == 49285256);
  assert(mult_int(8, 6160658) == 49285264);
  assert(mult_int(8, 6160659) == 49285272);
  assert(mult_int(8, 6160660) == 49285280);
  assert(mult_int(8, 6160661) == 49285288);
  assert(mult_int(8, 6160662) == 49285296);
  assert(mult_int(8, 6160663) == 49285304);
  assert(mult_int(8, 6160664) == 49285312);
  assert(mult_int(8, 6160665) == 49285320);
  assert(mult_int(8, 6160666) == 49285328);
  assert(mult_int(8, 6160667) == 49285336);
  assert(mult_int(8, 6160668) == 49285344);
  assert(mult_int(8, 6160669) == 49285352);
  assert(mult_int(8, 6160670) == 49285360);
  assert(mult_int(8, 6160671) == 49285368);
  assert(mult_int(8, 6160672) == 49285376);
  assert(mult_int(8, 6160673) == 49285384);
  assert(mult_int(8, 6160674) == 49285392);
  assert(mult_int(8, 6160675) == 49285400);
  assert(mult_int(8, 6160676) == 49285408);
  assert(mult_int(8, 6160677) == 49285416);
  assert(mult_int(8, 6160678) == 49285424);
  assert(mult_int(8, 6160679) == 49285432);
  assert(mult_int(8, 6160680) == 49285440);
  assert(mult_int(8, 6160681) == 49285448);
  assert(mult_int(8, 6160682) == 49285456);
  assert(mult_int(8, 6160683) == 49285464);
  assert(mult_int(8, 6160684) == 49285472);
  assert(mult_int(8, 6160685) == 49285480);
  assert(mult_int(8, 6160686) == 49285488);
  assert(mult_int(8, 6160687) == 49285496);
  assert(mult_int(8, 6160688) == 49285504);
  assert(mult_int(8, 6160689) == 49285512);
  assert(mult_int(8, 6160690) == 49285520);
  assert(mult_int(8, 6160691) == 49285528);
  assert(mult_int(8, 6160692) == 49285536);
  assert(mult_int(8, 6160693) == 49285544);
  assert(mult_int(8, 6160694) == 49285552);
  assert(mult_int(8, 6160695) == 49285560);
  assert(mult_int(8, 6160696) == 49285568);
  assert(mult_int(8, 6160697) == 49285576);
  assert(mult_int(8, 6160698) == 49285584);
  assert(mult_int(8, 6160699) == 49285592);
  assert(mult_int(8, 6160700) == 49285600);
  assert(mult_int(8, 6160701) == 49285608);
  assert(mult_int(8, 6160702) == 49285616);
  assert(mult_int(8, 6160703) == 49285624);
  assert(mult_int(8, 6160704) == 49285632);
  assert(mult_int(8, 6160705) == 49285640);
  assert(mult_int(8, 6160706) == 49285648);
  assert(mult_int(8, 6160707) == 49285656);
  assert(mult_int(8, 6160708) == 49285664);
  assert(mult_int(8, 6160709) == 49285672);
  assert(mult_int(8, 6160710) == 49285680);
  assert(mult_int(8, 6160711) == 49285688);
  assert(mult_int(8, 6160712) == 49285696);
  assert(mult_int(8, 6160713) == 49285704);
  assert(mult_int(8, 6160714) == 49285712);
  assert(mult_int(8, 6160715) == 49285720);
  assert(mult_int(8, 6160716) == 49285728);
  assert(mult_int(8, 6160717) == 49285736);
  assert(mult_int(8, 6160718) == 49285744);
  assert(mult_int(8, 6160719) == 49285752);
  assert(mult_int(8, 6160720) == 49285760);
  assert(mult_int(8, 6160721) == 49285768);
  assert(mult_int(8, 6160722) == 49285776);
  assert(mult_int(8, 6160723) == 49285784);
  assert(mult_int(8, 6160724) == 49285792);
  assert(mult_int(8, 6160725) == 49285800);
  assert(mult_int(8, 6160726) == 49285808);
  assert(mult_int(8, 6160727) == 49285816);
  assert(mult_int(8, 6160728) == 49285824);
  assert(mult_int(8, 6160729) == 49285832);
  assert(mult_int(8, 6160730) == 49285840);
  assert(mult_int(8, 6160731) == 49285848);
  assert(mult_int(8, 6160732) == 49285856);
  assert(mult_int(8, 6160733) == 49285864);
  assert(mult_int(8, 6160734) == 49285872);
  assert(mult_int(8, 6160735) == 49285880);
  assert(mult_int(8, 6160736) == 49285888);
  assert(mult_int(8, 6160737) == 49285896);
  assert(mult_int(8, 6160738) == 49285904);
  assert(mult_int(8, 6160739) == 49285912);
  assert(mult_int(8, 6160740) == 49285920);
  assert(mult_int(8, 6160741) == 49285928);
  assert(mult_int(8, 6160742) == 49285936);
  assert(mult_int(8, 6160743) == 49285944);
  assert(mult_int(8, 6160744) == 49285952);
  assert(mult_int(8, 6160745) == 49285960);
  assert(mult_int(8, 6160746) == 49285968);
  assert(mult_int(8, 6160747) == 49285976);
  assert(mult_int(8, 6160748) == 49285984);
  assert(mult_int(8, 6160749) == 49285992);
  assert(mult_int(8, 6160750) == 49286000);
  assert(mult_int(8, 6160751) == 49286008);
  assert(mult_int(8, 6160752) == 49286016);
  assert(mult_int(8, 6160753) == 49286024);
  assert(mult_int(8, 6160754) == 49286032);
  assert(mult_int(8, 6160755) == 49286040);
  assert(mult_int(8, 6160756) == 49286048);
  assert(mult_int(8, 6160757) == 49286056);
  assert(mult_int(8, 6160758) == 49286064);
  assert(mult_int(8, 6160759) == 49286072);
  assert(mult_int(8, 6160760) == 49286080);
  assert(mult_int(8, 6160761) == 49286088);
  assert(mult_int(8, 6160762) == 49286096);
  assert(mult_int(8, 6160763) == 49286104);
  assert(mult_int(8, 6160764) == 49286112);
  assert(mult_int(8, 6160765) == 49286120);
  assert(mult_int(8, 6160766) == 49286128);
  assert(mult_int(8, 6160767) == 49286136);
  assert(mult_int(8, 6160768) == 49286144);
  assert(mult_int(8, 6160769) == 49286152);
  assert(mult_int(8, 6160770) == 49286160);
  assert(mult_int(8, 6160771) == 49286168);
  assert(mult_int(8, 6160772) == 49286176);
  assert(mult_int(8, 6160773) == 49286184);
  assert(mult_int(8, 6160774) == 49286192);
  assert(mult_int(8, 6160775) == 49286200);
  assert(mult_int(8, 6160776) == 49286208);
  assert(mult_int(8, 6160777) == 49286216);
  assert(mult_int(8, 6160778) == 49286224);
  assert(mult_int(8, 6160779) == 49286232);
  assert(mult_int(8, 6160780) == 49286240);
  assert(mult_int(8, 6160781) == 49286248);
  assert(mult_int(8, 6160782) == 49286256);
  assert(mult_int(8, 6160783) == 49286264);
  assert(mult_int(8, 6160784) == 49286272);
  assert(mult_int(8, 6160785) == 49286280);
  assert(mult_int(8, 6160786) == 49286288);
  assert(mult_int(8, 6160787) == 49286296);
  assert(mult_int(8, 6160788) == 49286304);
  assert(mult_int(8, 6160789) == 49286312);
  assert(mult_int(8, 6160790) == 49286320);
  assert(mult_int(8, 6160791) == 49286328);
  assert(mult_int(8, 6160792) == 49286336);
  assert(mult_int(8, 6160793) == 49286344);
  assert(mult_int(8, 6160794) == 49286352);
  assert(mult_int(8, 6160795) == 49286360);
  assert(mult_int(8, 6160796) == 49286368);
  assert(mult_int(8, 6160797) == 49286376);
  assert(mult_int(8, 6160798) == 49286384);
  assert(mult_int(8, 6160799) == 49286392);
  assert(mult_int(8, 6160800) == 49286400);
  assert(mult_int(8, 6160801) == 49286408);
  assert(mult_int(8, 6160802) == 49286416);
  assert(mult_int(8, 6160803) == 49286424);
  assert(mult_int(8, 6160804) == 49286432);
  assert(mult_int(8, 6160805) == 49286440);
  assert(mult_int(8, 6160806) == 49286448);
  assert(mult_int(8, 6160807) == 49286456);
  assert(mult_int(8, 6160808) == 49286464);
  assert(mult_int(8, 6160809) == 49286472);
  assert(mult_int(8, 6160810) == 49286480);
  assert(mult_int(8, 6160811) == 49286488);
  assert(mult_int(8, 6160812) == 49286496);
  assert(mult_int(8, 6160813) == 49286504);
  assert(mult_int(8, 6160814) == 49286512);
  assert(mult_int(8, 6160815) == 49286520);
  assert(mult_int(8, 6160816) == 49286528);
  assert(mult_int(8, 6160817) == 49286536);
  assert(mult_int(8, 6160818) == 49286544);
  assert(mult_int(8, 6160819) == 49286552);
  assert(mult_int(8, 6160820) == 49286560);
  assert(mult_int(8, 6160821) == 49286568);
  assert(mult_int(8, 6160822) == 49286576);
  assert(mult_int(8, 6160823) == 49286584);
  assert(mult_int(8, 6160824) == 49286592);
  assert(mult_int(8, 6160825) == 49286600);
  assert(mult_int(8, 6160826) == 49286608);
  assert(mult_int(8, 6160827) == 49286616);
  assert(mult_int(8, 6160828) == 49286624);
  assert(mult_int(8, 6160829) == 49286632);
  assert(mult_int(8, 6160830) == 49286640);
  assert(mult_int(8, 6168832) == 49350656);
  assert(mult_int(8, 6193152) == 49545216);
  assert(mult_int(8, 6201344) == 49610752);
  assert(mult_int(8, 6201352) == 49610816);
  assert(mult_int(8, 6209600) == 49676800);
  assert(mult_int(8, 6217984) == 49743872);
  assert(mult_int(8, 6291540) == 50332320);
  assert(mult_int(8, 6292776) == 50342208);
  assert(mult_int(8, 6295974) == 50367792);
  assert(mult_int(8, 6295975) == 50367800);
  assert(mult_int(8, 6295976) == 50367808);
  assert(mult_int(8, 6295977) == 50367816);
  assert(mult_int(8, 6295978) == 50367824);
  assert(mult_int(8, 6295979) == 50367832);
  assert(mult_int(8, 6295980) == 50367840);
  assert(mult_int(8, 6295981) == 50367848);
  assert(mult_int(8, 6295982) == 50367856);
  assert(mult_int(8, 6295983) == 50367864);
  assert(mult_int(8, 6295984) == 50367872);
  assert(mult_int(8, 6295985) == 50367880);
  assert(mult_int(8, 6295986) == 50367888);
  assert(mult_int(8, 6295987) == 50367896);
  assert(mult_int(8, 6295988) == 50367904);
  assert(mult_int(8, 6295989) == 50367912);
  assert(mult_int(8, 6295990) == 50367920);
  assert(mult_int(8, 6295991) == 50367928);
  assert(mult_int(8, 6295992) == 50367936);
  assert(mult_int(8, 6295993) == 50367944);
  assert(mult_int(8, 6295994) == 50367952);
  assert(mult_int(8, 6295995) == 50367960);
  assert(mult_int(8, 6295996) == 50367968);
  assert(mult_int(8, 6295997) == 50367976);
  assert(mult_int(8, 6295998) == 50367984);
  assert(mult_int(8, 6295999) == 50367992);
  assert(mult_int(8, 6296000) == 50368000);
  assert(mult_int(8, 6296001) == 50368008);
  assert(mult_int(8, 6296002) == 50368016);
  assert(mult_int(8, 6296003) == 50368024);
  assert(mult_int(8, 6296004) == 50368032);
  assert(mult_int(8, 6296005) == 50368040);
  assert(mult_int(8, 6296006) == 50368048);
  assert(mult_int(8, 6296007) == 50368056);
  assert(mult_int(8, 6406144) == 51249152);
  assert(mult_int(8, 6414336) == 51314688);
  assert(mult_int(8, 6422528) == 51380224);
  assert(mult_int(8, 6422536) == 51380288);
  assert(mult_int(8, 6430785) == 51446280);
  assert(mult_int(8, 6439168) == 51513344);
  assert(mult_int(8, 6529076) == 52232608);
  assert(mult_int(8, 6529080) == 52232640);
  assert(mult_int(8, 6529084) == 52232672);
  assert(mult_int(8, 6529085) == 52232680);
  assert(mult_int(8, 6529086) == 52232688);
  assert(mult_int(8, 6529088) == 52232704);
  assert(mult_int(8, 6529089) == 52232712);
  assert(mult_int(8, 6529091) == 52232728);
  assert(mult_int(8, 6529092) == 52232736);
  assert(mult_int(8, 6529093) == 52232744);
  assert(mult_int(8, 6529094) == 52232752);
  assert(mult_int(8, 6529097) == 52232776);
  assert(mult_int(8, 6529098) == 52232784);
  assert(mult_int(8, 6529099) == 52232792);
  assert(mult_int(8, 6529100) == 52232800);
  assert(mult_int(8, 6529119) == 52232952);
  assert(mult_int(8, 6529120) == 52232960);
  assert(mult_int(8, 6529121) == 52232968);
  assert(mult_int(8, 6529123) == 52232984);
  assert(mult_int(8, 6529124) == 52232992);
  assert(mult_int(8, 6529125) == 52233000);
  assert(mult_int(8, 6529298) == 52234384);
  assert(mult_int(8, 6529299) == 52234392);
  assert(mult_int(8, 6529300) == 52234400);
  assert(mult_int(8, 6529480) == 52235840);
  assert(mult_int(8, 6529481) == 52235848);
  assert(mult_int(8, 6529482) == 52235856);
  assert(mult_int(8, 6529557) == 52236456);
  assert(mult_int(8, 6529558) == 52236464);
  assert(mult_int(8, 6529567) == 52236536);
  assert(mult_int(8, 6529568) == 52236544);
  assert(mult_int(8, 6529569) == 52236552);
  assert(mult_int(8, 6529570) == 52236560);
  assert(mult_int(8, 6529581) == 52236648);
  assert(mult_int(8, 6529582) == 52236656);
  assert(mult_int(8, 6529583) == 52236664);
  assert(mult_int(8, 6529650) == 52237200);
  assert(mult_int(8, 6529651) == 52237208);
  assert(mult_int(8, 6529652) == 52237216);
  assert(mult_int(8, 6529653) == 52237224);
  assert(mult_int(8, 6529654) == 52237232);
  assert(mult_int(8, 6529655) == 52237240);
  assert(mult_int(8, 6529656) == 52237248);
  assert(mult_int(8, 6529657) == 52237256);
  assert(mult_int(8, 6529658) == 52237264);
  assert(mult_int(8, 6529659) == 52237272);
  assert(mult_int(8, 6529660) == 52237280);
  assert(mult_int(8, 6529661) == 52237288);
  assert(mult_int(8, 6529662) == 52237296);
  assert(mult_int(8, 6529663) == 52237304);
  assert(mult_int(8, 6529664) == 52237312);
  assert(mult_int(8, 6529665) == 52237320);
  assert(mult_int(8, 6529666) == 52237328);
  assert(mult_int(8, 6529667) == 52237336);
  assert(mult_int(8, 6529668) == 52237344);
  assert(mult_int(8, 6529669) == 52237352);
  assert(mult_int(8, 6529670) == 52237360);
  assert(mult_int(8, 6529671) == 52237368);
  assert(mult_int(8, 6529672) == 52237376);
  assert(mult_int(8, 6529673) == 52237384);
  assert(mult_int(8, 6529674) == 52237392);
  assert(mult_int(8, 6529675) == 52237400);
  assert(mult_int(8, 6529676) == 52237408);
  assert(mult_int(8, 6529677) == 52237416);
  assert(mult_int(8, 6529678) == 52237424);
  assert(mult_int(8, 6529679) == 52237432);
  assert(mult_int(8, 6529680) == 52237440);
  assert(mult_int(8, 6529681) == 52237448);
  assert(mult_int(8, 6529682) == 52237456);
  assert(mult_int(8, 6529683) == 52237464);
  assert(mult_int(8, 6529684) == 52237472);
  assert(mult_int(8, 6529685) == 52237480);
  assert(mult_int(8, 6529686) == 52237488);
  assert(mult_int(8, 6529687) == 52237496);
  assert(mult_int(8, 6529688) == 52237504);
  assert(mult_int(8, 6529689) == 52237512);
  assert(mult_int(8, 6529690) == 52237520);
  assert(mult_int(8, 6529691) == 52237528);
  assert(mult_int(8, 6529692) == 52237536);
  assert(mult_int(8, 6529693) == 52237544);
  assert(mult_int(8, 6529694) == 52237552);
  assert(mult_int(8, 6529695) == 52237560);
  assert(mult_int(8, 6529696) == 52237568);
  assert(mult_int(8, 6529697) == 52237576);
  assert(mult_int(8, 6529698) == 52237584);
  assert(mult_int(8, 6529699) == 52237592);
  assert(mult_int(8, 6529700) == 52237600);
  assert(mult_int(8, 6529701) == 52237608);
  assert(mult_int(8, 6529702) == 52237616);
  assert(mult_int(8, 6529703) == 52237624);
  assert(mult_int(8, 6529704) == 52237632);
  assert(mult_int(8, 6529705) == 52237640);
  assert(mult_int(8, 6529706) == 52237648);
  assert(mult_int(8, 6529707) == 52237656);
  assert(mult_int(8, 6529708) == 52237664);
  assert(mult_int(8, 6529709) == 52237672);
  assert(mult_int(8, 6529710) == 52237680);
  assert(mult_int(8, 6529711) == 52237688);
  assert(mult_int(8, 6529712) == 52237696);
  assert(mult_int(8, 6529713) == 52237704);
  assert(mult_int(8, 6529714) == 52237712);
  assert(mult_int(8, 6529715) == 52237720);
  assert(mult_int(8, 6529716) == 52237728);
  assert(mult_int(8, 6529717) == 52237736);
  assert(mult_int(8, 6529718) == 52237744);
  assert(mult_int(8, 6529719) == 52237752);
  assert(mult_int(8, 6529720) == 52237760);
  assert(mult_int(8, 6529721) == 52237768);
  assert(mult_int(8, 6529722) == 52237776);
  assert(mult_int(8, 6529723) == 52237784);
  assert(mult_int(8, 6529724) == 52237792);
  assert(mult_int(8, 6529725) == 52237800);
  assert(mult_int(8, 6529726) == 52237808);
  assert(mult_int(8, 6529727) == 52237816);
  assert(mult_int(8, 6529728) == 52237824);
  assert(mult_int(8, 6529729) == 52237832);
  assert(mult_int(8, 6529730) == 52237840);
  assert(mult_int(8, 6529731) == 52237848);
  assert(mult_int(8, 6529732) == 52237856);
  assert(mult_int(8, 6529733) == 52237864);
  assert(mult_int(8, 6529734) == 52237872);
  assert(mult_int(8, 6529735) == 52237880);
  assert(mult_int(8, 6529736) == 52237888);
  assert(mult_int(8, 6529737) == 52237896);
  assert(mult_int(8, 6529738) == 52237904);
  assert(mult_int(8, 6529739) == 52237912);
  assert(mult_int(8, 6529740) == 52237920);
  assert(mult_int(8, 6529741) == 52237928);
  assert(mult_int(8, 6529742) == 52237936);
  assert(mult_int(8, 6529743) == 52237944);
  assert(mult_int(8, 6529744) == 52237952);
  assert(mult_int(8, 6529745) == 52237960);
  assert(mult_int(8, 6529746) == 52237968);
  assert(mult_int(8, 6529747) == 52237976);
  assert(mult_int(8, 6529748) == 52237984);
  assert(mult_int(8, 6529749) == 52237992);
  assert(mult_int(8, 6529750) == 52238000);
  assert(mult_int(8, 6529751) == 52238008);
  assert(mult_int(8, 6529752) == 52238016);
  assert(mult_int(8, 6529753) == 52238024);
  assert(mult_int(8, 6529754) == 52238032);
  assert(mult_int(8, 6529755) == 52238040);
  assert(mult_int(8, 6529756) == 52238048);
  assert(mult_int(8, 6529757) == 52238056);
  assert(mult_int(8, 6529758) == 52238064);
  assert(mult_int(8, 6529759) == 52238072);
  assert(mult_int(8, 6529760) == 52238080);
  assert(mult_int(8, 6529761) == 52238088);
  assert(mult_int(8, 6529762) == 52238096);
  assert(mult_int(8, 6529763) == 52238104);
  assert(mult_int(8, 6529764) == 52238112);
  assert(mult_int(8, 6529765) == 52238120);
  assert(mult_int(8, 6529766) == 52238128);
  assert(mult_int(8, 6529767) == 52238136);
  assert(mult_int(8, 6529768) == 52238144);
  assert(mult_int(8, 6529769) == 52238152);
  assert(mult_int(8, 6529770) == 52238160);
  assert(mult_int(8, 6529771) == 52238168);
  assert(mult_int(8, 6529772) == 52238176);
  assert(mult_int(8, 6529773) == 52238184);
  assert(mult_int(8, 6529774) == 52238192);
  assert(mult_int(8, 6529786) == 52238288);
  assert(mult_int(8, 6529788) == 52238304);
  assert(mult_int(8, 6529789) == 52238312);
  assert(mult_int(8, 6529790) == 52238320);
  assert(mult_int(8, 6529791) == 52238328);
  assert(mult_int(8, 6529792) == 52238336);
  assert(mult_int(8, 7340133) == 58721064);
  assert(mult_int(8, 7340134) == 58721072);
  assert(mult_int(8, 7340135) == 58721080);
  assert(mult_int(8, 7340136) == 58721088);
  assert(mult_int(8, 7340138) == 58721104);
  assert(mult_int(8, 7340139) == 58721112);
  assert(mult_int(8, 7340140) == 58721120);
  assert(mult_int(8, 7340141) == 58721128);
  assert(mult_int(8, 7340148) == 58721184);
  assert(mult_int(8, 7340149) == 58721192);
  assert(mult_int(8, 7340150) == 58721200);
  assert(mult_int(8, 7340151) == 58721208);
  assert(mult_int(8, 7340152) == 58721216);
  assert(mult_int(8, 7340154) == 58721232);
  assert(mult_int(8, 7340155) == 58721240);
  assert(mult_int(8, 7340156) == 58721248);
  assert(mult_int(8, 7340157) == 58721256);
  assert(mult_int(8, 7340158) == 58721264);
  assert(mult_int(8, 7353913) == 58831304);
  assert(mult_int(8, 7353914) == 58831312);
  assert(mult_int(8, 7353915) == 58831320);
  assert(mult_int(8, 7353916) == 58831328);
  assert(mult_int(8, 7353917) == 58831336);
  assert(mult_int(8, 7353918) == 58831344);
  assert(mult_int(8, 7353919) == 58831352);
  assert(mult_int(8, 7353928) == 58831424);
  assert(mult_int(8, 7353929) == 58831432);
  assert(mult_int(8, 7353930) == 58831440);
  assert(mult_int(8, 7353931) == 58831448);
  assert(mult_int(8, 7353932) == 58831456);
  assert(mult_int(8, 7353934) == 58831472);
  assert(mult_int(8, 7353935) == 58831480);
  assert(mult_int(8, 7353936) == 58831488);
  assert(mult_int(8, 7353937) == 58831496);
  assert(mult_int(8, 7353938) == 58831504);
  assert(mult_int(8, 7353939) == 58831512);
  assert(mult_int(8, 7353940) == 58831520);
  assert(mult_int(8, 7353941) == 58831528);
  assert(mult_int(8, 7353942) == 58831536);
  assert(mult_int(8, 7353943) == 58831544);
  assert(mult_int(8, 7353944) == 58831552);
  assert(mult_int(8, 7353945) == 58831560);
  assert(mult_int(8, 7353946) == 58831568);
  assert(mult_int(8, 7353947) == 58831576);
  assert(mult_int(8, 7353948) == 58831584);
  assert(mult_int(8, 7353949) == 58831592);
  assert(mult_int(8, 7353950) == 58831600);
  assert(mult_int(8, 7353951) == 58831608);
  assert(mult_int(8, 8) == 64);
  assert(mult_int(8, 8746) == 69968);
  assert(mult_int(8, 9412) == 75296);
  assert(mult_int(8, 9484) == 75872);
}