default Order dec

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

overload div_int = {tdiv_int}

function main (() : unit) -> unit = {
  assert(div_int(48240160, 8) == 6030020);
  assert(div_int(48240168, 8) == 6030021);
  assert(div_int(48240176, 8) == 6030022);
  assert(div_int(48240184, 8) == 6030023);
  assert(div_int(48240192, 8) == 6030024);
  assert(div_int(48240200, 8) == 6030025);
  assert(div_int(48240208, 8) == 6030026);
  assert(div_int(48240216, 8) == 6030027);
  assert(div_int(48240224, 8) == 6030028);
  assert(div_int(48240232, 8) == 6030029);
  assert(div_int(48240240, 8) == 6030030);
  assert(div_int(48240248, 8) == 6030031);
  assert(div_int(48240256, 8) == 6030032);
  assert(div_int(48240264, 8) == 6030033);
  assert(div_int(48240272, 8) == 6030034);
  assert(div_int(48240280, 8) == 6030035);
  assert(div_int(48240288, 8) == 6030036);
  assert(div_int(48240296, 8) == 6030037);
  assert(div_int(48240304, 8) == 6030038);
  assert(div_int(48240312, 8) == 6030039);
  assert(div_int(48240320, 8) == 6030040);
  assert(div_int(48240328, 8) == 6030041);
  assert(div_int(48240336, 8) == 6030042);
  assert(div_int(48240344, 8) == 6030043);
  assert(div_int(48240352, 8) == 6030044);
  assert(div_int(48240360, 8) == 6030045);
  assert(div_int(48240368, 8) == 6030046);
  assert(div_int(48240376, 8) == 6030047);
  assert(div_int(48240384, 8) == 6030048);
  assert(div_int(48240392, 8) == 6030049);
  assert(div_int(48240400, 8) == 6030050);
  assert(div_int(48240408, 8) == 6030051);
  assert(div_int(48240416, 8) == 6030052);
  assert(div_int(48240424, 8) == 6030053);
  assert(div_int(48240432, 8) == 6030054);
  assert(div_int(48240440, 8) == 6030055);
  assert(div_int(48240448, 8) == 6030056);
  assert(div_int(48240456, 8) == 6030057);
  assert(div_int(48240464, 8) == 6030058);
  assert(div_int(48240472, 8) == 6030059);
  assert(div_int(48240480, 8) == 6030060);
  assert(div_int(48240488, 8) == 6030061);
  assert(div_int(48240496, 8) == 6030062);
  assert(div_int(48240504, 8) == 6030063);
  assert(div_int(48240512, 8) == 6030064);
  assert(div_int(48240520, 8) == 6030065);
  assert(div_int(48240528, 8) == 6030066);
  assert(div_int(48240536, 8) == 6030067);
  assert(div_int(48240544, 8) == 6030068);
  assert(div_int(48240552, 8) == 6030069);
  assert(div_int(48240560, 8) == 6030070);
  assert(div_int(48240568, 8) == 6030071);
  assert(div_int(48240576, 8) == 6030072);
  assert(div_int(48240584, 8) == 6030073);
  assert(div_int(48240592, 8) == 6030074);
  assert(div_int(48240600, 8) == 6030075);
  assert(div_int(48240608, 8) == 6030076);
  assert(div_int(48240616, 8) == 6030077);
  assert(div_int(48240624, 8) == 6030078);
  assert(div_int(48240632, 8) == 6030079);
  assert(div_int(48240640, 8) == 6030080);
  assert(div_int(48240648, 8) == 6030081);
  assert(div_int(48240656, 8) == 6030082);
  assert(div_int(48240664, 8) == 6030083);
  assert(div_int(48240672, 8) == 6030084);
  assert(div_int(48240680, 8) == 6030085);
  assert(div_int(48240688, 8) == 6030086);
  assert(div_int(48240696, 8) == 6030087);
  assert(div_int(48240704, 8) == 6030088);
  assert(div_int(48240712, 8) == 6030089);
  assert(div_int(48240720, 8) == 6030090);
  assert(div_int(48240728, 8) == 6030091);
  assert(div_int(48240736, 8) == 6030092);
  assert(div_int(48240744, 8) == 6030093);
  assert(div_int(48240752, 8) == 6030094);
  assert(div_int(48240760, 8) == 6030095);
  assert(div_int(48240768, 8) == 6030096);
  assert(div_int(48240776, 8) == 6030097);
  assert(div_int(48240784, 8) == 6030098);
  assert(div_int(48240792, 8) == 6030099);
  assert(div_int(48240800, 8) == 6030100);
  assert(div_int(48240808, 8) == 6030101);
  assert(div_int(48240816, 8) == 6030102);
  assert(div_int(48240824, 8) == 6030103);
  assert(div_int(48955392, 8) == 6119424);
  assert(div_int(49020928, 8) == 6127616);
  assert(div_int(49152000, 8) == 6144000);
  assert(div_int(49217536, 8) == 6152192);
  assert(div_int(49217600, 8) == 6152200);
  assert(div_int(49283080, 8) == 6160385);
  assert(div_int(49283088, 8) == 6160386);
  assert(div_int(49283096, 8) == 6160387);
  assert(div_int(49283104, 8) == 6160388);
  assert(div_int(49283112, 8) == 6160389);
  assert(div_int(49283120, 8) == 6160390);
  assert(div_int(49283128, 8) == 6160391);
  assert(div_int(49283136, 8) == 6160392);
  assert(div_int(49283144, 8) == 6160393);
  assert(div_int(49283152, 8) == 6160394);
  assert(div_int(49283160, 8) == 6160395);
  assert(div_int(49283168, 8) == 6160396);
  assert(div_int(49283176, 8) == 6160397);
  assert(div_int(49283184, 8) == 6160398);
  assert(div_int(49283192, 8) == 6160399);
  assert(div_int(49283200, 8) == 6160400);
  assert(div_int(49283208, 8) == 6160401);
  assert(div_int(49283216, 8) == 6160402);
  assert(div_int(49283224, 8) == 6160403);
  assert(div_int(49283232, 8) == 6160404);
  assert(div_int(49283240, 8) == 6160405);
  assert(div_int(49283248, 8) == 6160406);
  assert(div_int(49283256, 8) == 6160407);
  assert(div_int(49283264, 8) == 6160408);
  assert(div_int(49283272, 8) == 6160409);
  assert(div_int(49283280, 8) == 6160410);
  assert(div_int(49283288, 8) == 6160411);
  assert(div_int(49283296, 8) == 6160412);
  assert(div_int(49283304, 8) == 6160413);
  assert(div_int(49283312, 8) == 6160414);
  assert(div_int(49283320, 8) == 6160415);
  assert(div_int(49283328, 8) == 6160416);
  assert(div_int(49283336, 8) == 6160417);
  assert(div_int(49283344, 8) == 6160418);
  assert(div_int(49283352, 8) == 6160419);
  assert(div_int(49283360, 8) == 6160420);
  assert(div_int(49283368, 8) == 6160421);
  assert(div_int(49283376, 8) == 6160422);
  assert(div_int(49283384, 8) == 6160423);
  assert(div_int(49283392, 8) == 6160424);
  assert(div_int(49283400, 8) == 6160425);
  assert(div_int(49283408, 8) == 6160426);
  assert(div_int(49283416, 8) == 6160427);
  assert(div_int(49283424, 8) == 6160428);
  assert(div_int(49283432, 8) == 6160429);
  assert(div_int(49283440, 8) == 6160430);
  assert(div_int(49283448, 8) == 6160431);
  assert(div_int(49283456, 8) == 6160432);
  assert(div_int(49283464, 8) == 6160433);
  assert(div_int(49283472, 8) == 6160434);
  assert(div_int(49283480, 8) == 6160435);
  assert(div_int(49283488, 8) == 6160436);
  assert(div_int(49283496, 8) == 6160437);
  assert(div_int(49283504, 8) == 6160438);
  assert(div_int(49283512, 8) == 6160439);
  assert(div_int(49283520, 8) == 6160440);
  assert(div_int(49283528, 8) == 6160441);
  assert(div_int(49283536, 8) == 6160442);
  assert(div_int(49283544, 8) == 6160443);
  assert(div_int(49283552, 8) == 6160444);
  assert(div_int(49283560, 8) == 6160445);
  assert(div_int(49283568, 8) == 6160446);
  assert(div_int(49283576, 8) == 6160447);
  assert(div_int(49283584, 8) == 6160448);
  assert(div_int(49283592, 8) == 6160449);
  assert(div_int(49283600, 8) == 6160450);
  assert(div_int(49283608, 8) == 6160451);
  assert(div_int(49283616, 8) == 6160452);
  assert(div_int(49283624, 8) == 6160453);
  assert(div_int(49283632, 8) == 6160454);
  assert(div_int(49283640, 8) == 6160455);
  assert(div_int(49283648, 8) == 6160456);
  assert(div_int(49283656, 8) == 6160457);
  assert(div_int(49283664, 8) == 6160458);
  assert(div_int(49283672, 8) == 6160459);
  assert(div_int(49283680, 8) == 6160460);
  assert(div_int(49283688, 8) == 6160461);
  assert(div_int(49283696, 8) == 6160462);
  assert(div_int(49283704, 8) == 6160463);
  assert(div_int(49283712, 8) == 6160464);
  assert(div_int(49283720, 8) == 6160465);
  assert(div_int(49283728, 8) == 6160466);
  assert(div_int(49283736, 8) == 6160467);
  assert(div_int(49283744, 8) == 6160468);
  assert(div_int(49283752, 8) == 6160469);
  assert(div_int(49283760, 8) == 6160470);
  assert(div_int(49283768, 8) == 6160471);
  assert(div_int(49283776, 8) == 6160472);
  assert(div_int(49283784, 8) == 6160473);
  assert(div_int(49283792, 8) == 6160474);
  assert(div_int(49283800, 8) == 6160475);
  assert(div_int(49283808, 8) == 6160476);
  assert(div_int(49283816, 8) == 6160477);
  assert(div_int(49283824, 8) == 6160478);
  assert(div_int(49283832, 8) == 6160479);
  assert(div_int(49283840, 8) == 6160480);
  assert(div_int(49283848, 8) == 6160481);
  assert(div_int(49283856, 8) == 6160482);
  assert(div_int(49283864, 8) == 6160483);
  assert(div_int(49283872, 8) == 6160484);
  assert(div_int(49283880, 8) == 6160485);
  assert(div_int(49283888, 8) == 6160486);
  assert(div_int(49283896, 8) == 6160487);
  assert(div_int(49283904, 8) == 6160488);
  assert(div_int(49283912, 8) == 6160489);
  assert(div_int(49283920, 8) == 6160490);
  assert(div_int(49283928, 8) == 6160491);
  assert(div_int(49283936, 8) == 6160492);
  assert(div_int(49283944, 8) == 6160493);
  assert(div_int(49283952, 8) == 6160494);
  assert(div_int(49283960, 8) == 6160495);
  assert(div_int(49283968, 8) == 6160496);
  assert(div_int(49283976, 8) == 6160497);
  assert(div_int(49283984, 8) == 6160498);
  assert(div_int(49283992, 8) == 6160499);
  assert(div_int(49284000, 8) == 6160500);
  assert(div_int(49284008, 8) == 6160501);
  assert(div_int(49284016, 8) == 6160502);
  assert(div_int(49284024, 8) == 6160503);
  assert(div_int(49284032, 8) == 6160504);
  assert(div_int(49284040, 8) == 6160505);
  assert(div_int(49284048, 8) == 6160506);
  assert(div_int(49284056, 8) == 6160507);
  assert(div_int(49284064, 8) == 6160508);
  assert(div_int(49284072, 8) == 6160509);
  assert(div_int(49284080, 8) == 6160510);
  assert(div_int(49284088, 8) == 6160511);
  assert(div_int(49284096, 8) == 6160512);
  assert(div_int(49284104, 8) == 6160513);
  assert(div_int(49284112, 8) == 6160514);
  assert(div_int(49284120, 8) == 6160515);
  assert(div_int(49284128, 8) == 6160516);
  assert(div_int(49284136, 8) == 6160517);
  assert(div_int(49284144, 8) == 6160518);
  assert(div_int(49284152, 8) == 6160519);
  assert(div_int(49284160, 8) == 6160520);
  assert(div_int(49284168, 8) == 6160521);
  assert(div_int(49284176, 8) == 6160522);
  assert(div_int(49284184, 8) == 6160523);
  assert(div_int(49284192, 8) == 6160524);
  assert(div_int(49284200, 8) == 6160525);
  assert(div_int(49284208, 8) == 6160526);
  assert(div_int(49284216, 8) == 6160527);
  assert(div_int(49284224, 8) == 6160528);
  assert(div_int(49284232, 8) == 6160529);
  assert(div_int(49284240, 8) == 6160530);
  assert(div_int(49284248, 8) == 6160531);
  assert(div_int(49284256, 8) == 6160532);
  assert(div_int(49284264, 8) == 6160533);
  assert(div_int(49284272, 8) == 6160534);
  assert(div_int(49284280, 8) == 6160535);
  assert(div_int(49284288, 8) == 6160536);
  assert(div_int(49284296, 8) == 6160537);
  assert(div_int(49284304, 8) == 6160538);
  assert(div_int(49284312, 8) == 6160539);
  assert(div_int(49284320, 8) == 6160540);
  assert(div_int(49284328, 8) == 6160541);
  assert(div_int(49284336, 8) == 6160542);
  assert(div_int(49284344, 8) == 6160543);
  assert(div_int(49284352, 8) == 6160544);
  assert(div_int(49284360, 8) == 6160545);
  assert(div_int(49284368, 8) == 6160546);
  assert(div_int(49284376, 8) == 6160547);
  assert(div_int(49284384, 8) == 6160548);
  assert(div_int(49284392, 8) == 6160549);
  assert(div_int(49284400, 8) == 6160550);
  assert(div_int(49284408, 8) == 6160551);
  assert(div_int(49284416, 8) == 6160552);
  assert(div_int(49284424, 8) == 6160553);
  assert(div_int(49284432, 8) == 6160554);
  assert(div_int(49284440, 8) == 6160555);
  assert(div_int(49284448, 8) == 6160556);
  assert(div_int(49284456, 8) == 6160557);
  assert(div_int(49284464, 8) == 6160558);
  assert(div_int(49284472, 8) == 6160559);
  assert(div_int(49284480, 8) == 6160560);
  assert(div_int(49284488, 8) == 6160561);
  assert(div_int(49284496, 8) == 6160562);
  assert(div_int(49284504, 8) == 6160563);
  assert(div_int(49284512, 8) == 6160564);
  assert(div_int(49284520, 8) == 6160565);
  assert(div_int(49284528, 8) == 6160566);
  assert(div_int(49284536, 8) == 6160567);
  assert(div_int(49284544, 8) == 6160568);
  assert(div_int(49284552, 8) == 6160569);
  assert(div_int(49284560, 8) == 6160570);
  assert(div_int(49284568, 8) == 6160571);
  assert(div_int(49284576, 8) == 6160572);
  assert(div_int(49284584, 8) == 6160573);
  assert(div_int(49284592, 8) == 6160574);
  assert(div_int(49284600, 8) == 6160575);
  assert(div_int(49284608, 8) == 6160576);
  assert(div_int(49284616, 8) == 6160577);
  assert(div_int(49284624, 8) == 6160578);
  assert(div_int(49284632, 8) == 6160579);
  assert(div_int(49284640, 8) == 6160580);
  assert(div_int(49284648, 8) == 6160581);
  assert(div_int(49284656, 8) == 6160582);
  assert(div_int(49284664, 8) == 6160583);
  assert(div_int(49284672, 8) == 6160584);
  assert(div_int(49284680, 8) == 6160585);
  assert(div_int(49284688, 8) == 6160586);
  assert(div_int(49284696, 8) == 6160587);
  assert(div_int(49284704, 8) == 6160588);
  assert(div_int(49284712, 8) == 6160589);
  assert(div_int(49284720, 8) == 6160590);
  assert(div_int(49284728, 8) == 6160591);
  assert(div_int(49284736, 8) == 6160592);
  assert(div_int(49284744, 8) == 6160593);
  assert(div_int(49284752, 8) == 6160594);
  assert(div_int(49284760, 8) == 6160595);
  assert(div_int(49284768, 8) == 6160596);
  assert(div_int(49284776, 8) == 6160597);
  assert(div_int(49284784, 8) == 6160598);
  assert(div_int(49284792, 8) == 6160599);
  assert(div_int(49284800, 8) == 6160600);
  assert(div_int(49284808, 8) == 6160601);
  assert(div_int(49284816, 8) == 6160602);
  assert(div_int(49284824, 8) == 6160603);
  assert(div_int(49284832, 8) == 6160604);
  assert(div_int(49284840, 8) == 6160605);
  assert(div_int(49284848, 8) == 6160606);
  assert(div_int(49284856, 8) == 6160607);
  assert(div_int(49284864, 8) == 6160608);
  assert(div_int(49284872, 8) == 6160609);
  assert(div_int(49284880, 8) == 6160610);
  assert(div_int(49284888, 8) == 6160611);
  assert(div_int(49284896, 8) == 6160612);
  assert(div_int(49284904, 8) == 6160613);
  assert(div_int(49284912, 8) == 6160614);
  assert(div_int(49284920, 8) == 6160615);
  assert(div_int(49284928, 8) == 6160616);
  assert(div_int(49284936, 8) == 6160617);
  assert(div_int(49284944, 8) == 6160618);
  assert(div_int(49284952, 8) == 6160619);
  assert(div_int(49284960, 8) == 6160620);
  assert(div_int(49284968, 8) == 6160621);
  assert(div_int(49284976, 8) == 6160622);
  assert(div_int(49284984, 8) == 6160623);
  assert(div_int(49284992, 8) == 6160624);
  assert(div_int(49285000, 8) == 6160625);
  assert(div_int(49285008, 8) == 6160626);
  assert(div_int(49285016, 8) == 6160627);
  assert(div_int(49285024, 8) == 6160628);
  assert(div_int(49285032, 8) == 6160629);
  assert(div_int(49285040, 8) == 6160630);
  assert(div_int(49285048, 8) == 6160631);
  assert(div_int(49285056, 8) == 6160632);
  assert(div_int(49285064, 8) == 6160633);
  assert(div_int(49285072, 8) == 6160634);
  assert(div_int(49285080, 8) == 6160635);
  assert(div_int(49285088, 8) == 6160636);
  assert(div_int(49285096, 8) == 6160637);
  assert(div_int(49285104, 8) == 6160638);
  assert(div_int(49285112, 8) == 6160639);
  assert(div_int(49285120, 8) == 6160640);
  assert(div_int(49285128, 8) == 6160641);
  assert(div_int(49285136, 8) == 6160642);
  assert(div_int(49285144, 8) == 6160643);
  assert(div_int(49285152, 8) == 6160644);
  assert(div_int(49285160, 8) == 6160645);
  assert(div_int(49285168, 8) == 6160646);
  assert(div_int(49285176, 8) == 6160647);
  assert(div_int(49285184, 8) == 6160648);
  assert(div_int(49285192, 8) == 6160649);
  assert(div_int(49285200, 8) == 6160650);
  assert(div_int(49285208, 8) == 6160651);
  assert(div_int(49285216, 8) == 6160652);
  assert(div_int(49285224, 8) == 6160653);
  assert(div_int(49285232, 8) == 6160654);
  assert(div_int(49285240, 8) == 6160655);
  assert(div_int(49285248, 8) == 6160656);
  assert(div_int(49285256, 8) == 6160657);
  assert(div_int(49285264, 8) == 6160658);
  assert(div_int(49285272, 8) == 6160659);
  assert(div_int(49285280, 8) == 6160660);
  assert(div_int(49285288, 8) == 6160661);
  assert(div_int(49285296, 8) == 6160662);
  assert(div_int(49285304, 8) == 6160663);
  assert(div_int(49285312, 8) == 6160664);
  assert(div_int(49285320, 8) == 6160665);
  assert(div_int(49285328, 8) == 6160666);
  assert(div_int(49285336, 8) == 6160667);
  assert(div_int(49285344, 8) == 6160668);
  assert(div_int(49285352, 8) == 6160669);
  assert(div_int(49285360, 8) == 6160670);
  assert(div_int(49285368, 8) == 6160671);
  assert(div_int(49285376, 8) == 6160672);
  assert(div_int(49285384, 8) == 6160673);
  assert(div_int(49285392, 8) == 6160674);
  assert(div_int(49285400, 8) == 6160675);
  assert(div_int(49285408, 8) == 6160676);
  assert(div_int(49285416, 8) == 6160677);
  assert(div_int(49285424, 8) == 6160678);
  assert(div_int(49285432, 8) == 6160679);
  assert(div_int(49285440, 8) == 6160680);
  assert(div_int(49285448, 8) == 6160681);
  assert(div_int(49285456, 8) == 6160682);
  assert(div_int(49285464, 8) == 6160683);
  assert(div_int(49285472, 8) == 6160684);
  assert(div_int(49285480, 8) == 6160685);
  assert(div_int(49285488, 8) == 6160686);
  assert(div_int(49285496, 8) == 6160687);
  assert(div_int(49285504, 8) == 6160688);
  assert(div_int(49285512, 8) == 6160689);
  assert(div_int(49285520, 8) == 6160690);
  assert(div_int(49285528, 8) == 6160691);
  assert(div_int(49285536, 8) == 6160692);
  assert(div_int(49285544, 8) == 6160693);
  assert(div_int(49285552, 8) == 6160694);
  assert(div_int(49285560, 8) == 6160695);
  assert(div_int(49285568, 8) == 6160696);
  assert(div_int(49285576, 8) == 6160697);
  assert(div_int(49285584, 8) == 6160698);
  assert(div_int(49285592, 8) == 6160699);
  assert(div_int(49285600, 8) == 6160700);
  assert(div_int(49285608, 8) == 6160701);
  assert(div_int(49285616, 8) == 6160702);
  assert(div_int(49285624, 8) == 6160703);
  assert(div_int(49285632, 8) == 6160704);
  assert(div_int(49285640, 8) == 6160705);
  assert(div_int(49285648, 8) == 6160706);
  assert(div_int(49285656, 8) == 6160707);
  assert(div_int(49285664, 8) == 6160708);
  assert(div_int(49285672, 8) == 6160709);
  assert(div_int(49285680, 8) == 6160710);
  assert(div_int(49285688, 8) == 6160711);
  assert(div_int(49285696, 8) == 6160712);
  assert(div_int(49285704, 8) == 6160713);
  assert(div_int(49285712, 8) == 6160714);
  assert(div_int(49285720, 8) == 6160715);
  assert(div_int(49285728, 8) == 6160716);
  assert(div_int(49285736, 8) == 6160717);
  assert(div_int(49285744, 8) == 6160718);
  assert(div_int(49285752, 8) == 6160719);
  assert(div_int(49285760, 8) == 6160720);
  assert(div_int(49285768, 8) == 6160721);
  assert(div_int(49285776, 8) == 6160722);
  assert(div_int(49285784, 8) == 6160723);
  assert(div_int(49285792, 8) == 6160724);
  assert(div_int(49285800, 8) == 6160725);
  assert(div_int(49285808, 8) == 6160726);
  assert(div_int(49285816, 8) == 6160727);
  assert(div_int(49285824, 8) == 6160728);
  assert(div_int(49285832, 8) == 6160729);
  assert(div_int(49285840, 8) == 6160730);
  assert(div_int(49285848, 8) == 6160731);
  assert(div_int(49285856, 8) == 6160732);
  assert(div_int(49285864, 8) == 6160733);
  assert(div_int(49285872, 8) == 6160734);
  assert(div_int(49285880, 8) == 6160735);
  assert(div_int(49285888, 8) == 6160736);
  assert(div_int(49285896, 8) == 6160737);
  assert(div_int(49285904, 8) == 6160738);
  assert(div_int(49285912, 8) == 6160739);
  assert(div_int(49285920, 8) == 6160740);
  assert(div_int(49285928, 8) == 6160741);
  assert(div_int(49285936, 8) == 6160742);
  assert(div_int(49285944, 8) == 6160743);
  assert(div_int(49285952, 8) == 6160744);
  assert(div_int(49285960, 8) == 6160745);
  assert(div_int(49285968, 8) == 6160746);
  assert(div_int(49285976, 8) == 6160747);
  assert(div_int(49285984, 8) == 6160748);
  assert(div_int(49285992, 8) == 6160749);
  assert(div_int(49286000, 8) == 6160750);
  assert(div_int(49286008, 8) == 6160751);
  assert(div_int(49286016, 8) == 6160752);
  assert(div_int(49286024, 8) == 6160753);
  assert(div_int(49286032, 8) == 6160754);
  assert(div_int(49286040, 8) == 6160755);
  assert(div_int(49286048, 8) == 6160756);
  assert(div_int(49286056, 8) == 6160757);
  assert(div_int(49286064, 8) == 6160758);
  assert(div_int(49286072, 8) == 6160759);
  assert(div_int(49286080, 8) == 6160760);
  assert(div_int(49286088, 8) == 6160761);
  assert(div_int(49286096, 8) == 6160762);
  assert(div_int(49286104, 8) == 6160763);
  assert(div_int(49286112, 8) == 6160764);
  assert(div_int(49286120, 8) == 6160765);
  assert(div_int(49286128, 8) == 6160766);
  assert(div_int(49286136, 8) == 6160767);
  assert(div_int(49286144, 8) == 6160768);
  assert(div_int(49286152, 8) == 6160769);
  assert(div_int(49286160, 8) == 6160770);
  assert(div_int(49286168, 8) == 6160771);
  assert(div_int(49286176, 8) == 6160772);
  assert(div_int(49286184, 8) == 6160773);
  assert(div_int(49286192, 8) == 6160774);
  assert(div_int(49286200, 8) == 6160775);
  assert(div_int(49286208, 8) == 6160776);
  assert(div_int(49286216, 8) == 6160777);
  assert(div_int(49286224, 8) == 6160778);
  assert(div_int(49286232, 8) == 6160779);
  assert(div_int(49286240, 8) == 6160780);
  assert(div_int(49286248, 8) == 6160781);
  assert(div_int(49286256, 8) == 6160782);
  assert(div_int(49286264, 8) == 6160783);
  assert(div_int(49286272, 8) == 6160784);
  assert(div_int(49286280, 8) == 6160785);
  assert(div_int(49286288, 8) == 6160786);
  assert(div_int(49286296, 8) == 6160787);
  assert(div_int(49286304, 8) == 6160788);
  assert(div_int(49286312, 8) == 6160789);
  assert(div_int(49286320, 8) == 6160790);
  assert(div_int(49286328, 8) == 6160791);
  assert(div_int(49286336, 8) == 6160792);
  assert(div_int(49286344, 8) == 6160793);
  assert(div_int(49286352, 8) == 6160794);
  assert(div_int(49286360, 8) == 6160795);
  assert(div_int(49286368, 8) == 6160796);
  assert(div_int(49286376, 8) == 6160797);
  assert(div_int(49286384, 8) == 6160798);
  assert(div_int(49286392, 8) == 6160799);
  assert(div_int(49286400, 8) == 6160800);
  assert(div_int(49286408, 8) == 6160801);
  assert(div_int(49286416, 8) == 6160802);
  assert(div_int(49286424, 8) == 6160803);
  assert(div_int(49286432, 8) == 6160804);
  assert(div_int(49286440, 8) == 6160805);
  assert(div_int(49286448, 8) == 6160806);
  assert(div_int(49286456, 8) == 6160807);
  assert(div_int(49286464, 8) == 6160808);
  assert(div_int(49286472, 8) == 6160809);
  assert(div_int(49286480, 8) == 6160810);
  assert(div_int(49286488, 8) == 6160811);
  assert(div_int(49286496, 8) == 6160812);
  assert(div_int(49286504, 8) == 6160813);
  assert(div_int(49286512, 8) == 6160814);
  assert(div_int(49286520, 8) == 6160815);
  assert(div_int(49286528, 8) == 6160816);
  assert(div_int(49286536, 8) == 6160817);
  assert(div_int(49286544, 8) == 6160818);
  assert(div_int(49286552, 8) == 6160819);
  assert(div_int(49286560, 8) == 6160820);
  assert(div_int(49286568, 8) == 6160821);
  assert(div_int(49286576, 8) == 6160822);
  assert(div_int(49286584, 8) == 6160823);
  assert(div_int(49286592, 8) == 6160824);
  assert(div_int(49286600, 8) == 6160825);
  assert(div_int(49286608, 8) == 6160826);
  assert(div_int(49286616, 8) == 6160827);
  assert(div_int(49286624, 8) == 6160828);
  assert(div_int(49286632, 8) == 6160829);
  assert(div_int(49286640, 8) == 6160830);
  assert(div_int(49350656, 8) == 6168832);
  assert(div_int(49545216, 8) == 6193152);
  assert(div_int(49610752, 8) == 6201344);
  assert(div_int(49610816, 8) == 6201352);
  assert(div_int(49676800, 8) == 6209600);
  assert(div_int(49743872, 8) == 6217984);
  assert(div_int(50331668, 4) == 12582917);
  assert(div_int(50331672, 4) == 12582918);
  assert(div_int(50331676, 4) == 12582919);
  assert(div_int(50331680, 4) == 12582920);
  assert(div_int(50331696, 4) == 12582924);
  assert(div_int(50331732, 4) == 12582933);
  assert(div_int(50331736, 4) == 12582934);
  assert(div_int(50331752, 4) == 12582938);
  assert(div_int(50331848, 4) == 12582962);
  assert(div_int(50332320, 8) == 6291540);
  assert(div_int(50342208, 8) == 6292776);
  assert(div_int(50359056, 4) == 12589764);
  assert(div_int(50359060, 4) == 12589765);
  assert(div_int(50367776, 1) == 50367776);
  assert(div_int(50367776, 16) == 3147986);
  assert(div_int(50367776, 4) == 12591944);
  assert(div_int(50367777, 1) == 50367777);
  assert(div_int(50367780, 4) == 12591945);
  assert(div_int(50367784, 4) == 12591946);
  assert(div_int(50367792, 8) == 6295974);
  assert(div_int(50367800, 8) == 6295975);
  assert(div_int(50367808, 16) == 3147988);
  assert(div_int(50367808, 8) == 6295976);
  assert(div_int(50367816, 8) == 6295977);
  assert(div_int(50367824, 1) == 50367824);
  assert(div_int(50367824, 16) == 3147989);
  assert(div_int(50367824, 4) == 12591956);
  assert(div_int(50367824, 8) == 6295978);
  assert(div_int(50367825, 1) == 50367825);
  assert(div_int(50367828, 4) == 12591957);
  assert(div_int(50367832, 4) == 12591958);
  assert(div_int(50367832, 8) == 6295979);
  assert(div_int(50367836, 4) == 12591959);
  assert(div_int(50367840, 4) == 12591960);
  assert(div_int(50367840, 8) == 6295980);
  assert(div_int(50367844, 4) == 12591961);
  assert(div_int(50367848, 4) == 12591962);
  assert(div_int(50367848, 8) == 6295981);
  assert(div_int(50367852, 4) == 12591963);
  assert(div_int(50367856, 16) == 3147991);
  assert(div_int(50367856, 4) == 12591964);
  assert(div_int(50367856, 8) == 6295982);
  assert(div_int(50367860, 4) == 12591965);
  assert(div_int(50367864, 4) == 12591966);
  assert(div_int(50367864, 8) == 6295983);
  assert(div_int(50367868, 4) == 12591967);
  assert(div_int(50367872, 1) == 50367872);
  assert(div_int(50367872, 16) == 3147992);
  assert(div_int(50367872, 4) == 12591968);
  assert(div_int(50367872, 8) == 6295984);
  assert(div_int(50367876, 4) == 12591969);
  assert(div_int(50367880, 4) == 12591970);
  assert(div_int(50367880, 8) == 6295985);
  assert(div_int(50367884, 4) == 12591971);
  assert(div_int(50367888, 4) == 12591972);
  assert(div_int(50367888, 8) == 6295986);
  assert(div_int(50367892, 4) == 12591973);
  assert(div_int(50367896, 4) == 12591974);
  assert(div_int(50367896, 8) == 6295987);
  assert(div_int(50367900, 4) == 12591975);
  assert(div_int(50367904, 16) == 3147994);
  assert(div_int(50367904, 4) == 12591976);
  assert(div_int(50367904, 8) == 6295988);
  assert(div_int(50367908, 4) == 12591977);
  assert(div_int(50367912, 4) == 12591978);
  assert(div_int(50367912, 8) == 6295989);
  assert(div_int(50367916, 4) == 12591979);
  assert(div_int(50367920, 16) == 3147995);
  assert(div_int(50367920, 4) == 12591980);
  assert(div_int(50367920, 8) == 6295990);
  assert(div_int(50367924, 4) == 12591981);
  assert(div_int(50367928, 4) == 12591982);
  assert(div_int(50367928, 8) == 6295991);
  assert(div_int(50367932, 4) == 12591983);
  assert(div_int(50367936, 4) == 12591984);
  assert(div_int(50367936, 8) == 6295992);
  assert(div_int(50367940, 4) == 12591985);
  assert(div_int(50367944, 4) == 12591986);
  assert(div_int(50367944, 8) == 6295993);
  assert(div_int(50367948, 4) == 12591987);
  assert(div_int(50367952, 4) == 12591988);
  assert(div_int(50367952, 8) == 6295994);
  assert(div_int(50367956, 4) == 12591989);
  assert(div_int(50367960, 4) == 12591990);
  assert(div_int(50367960, 8) == 6295995);
  assert(div_int(50367964, 4) == 12591991);
  assert(div_int(50367968, 16) == 3147998);
  assert(div_int(50367968, 4) == 12591992);
  assert(div_int(50367968, 8) == 6295996);
  assert(div_int(50367972, 4) == 12591993);
  assert(div_int(50367976, 4) == 12591994);
  assert(div_int(50367976, 8) == 6295997);
  assert(div_int(50367980, 4) == 12591995);
  assert(div_int(50367984, 16) == 3147999);
  assert(div_int(50367984, 8) == 6295998);
  assert(div_int(50367992, 8) == 6295999);
  assert(div_int(50368000, 16) == 3148000);
  assert(div_int(50368000, 8) == 6296000);
  assert(div_int(50368008, 8) == 6296001);
  assert(div_int(50368016, 16) == 3148001);
  assert(div_int(50368016, 8) == 6296002);
  assert(div_int(50368024, 8) == 6296003);
  assert(div_int(50368032, 16) == 3148002);
  assert(div_int(50368032, 8) == 6296004);
  assert(div_int(50368040, 8) == 6296005);
  assert(div_int(50368048, 8) == 6296006);
  assert(div_int(50368056, 8) == 6296007);
  assert(div_int(51249152, 8) == 6406144);
  assert(div_int(51314688, 8) == 6414336);
  assert(div_int(51380224, 8) == 6422528);
  assert(div_int(51380288, 8) == 6422536);
  assert(div_int(51446280, 8) == 6430785);
  assert(div_int(51513344, 8) == 6439168);
  assert(div_int(52232192, 4) == 13058048);
  assert(div_int(52232196, 4) == 13058049);
  assert(div_int(52232200, 4) == 13058050);
  assert(div_int(52232204, 4) == 13058051);
  assert(div_int(52232208, 4) == 13058052);
  assert(div_int(52232212, 4) == 13058053);
  assert(div_int(52232216, 4) == 13058054);
  assert(div_int(52232220, 4) == 13058055);
  assert(div_int(52232224, 4) == 13058056);
  assert(div_int(52232256, 4) == 13058064);
  assert(div_int(52232260, 4) == 13058065);
  assert(div_int(52232264, 4) == 13058066);
  assert(div_int(52232268, 4) == 13058067);
  assert(div_int(52232272, 4) == 13058068);
  assert(div_int(52232276, 4) == 13058069);
  assert(div_int(52232280, 4) == 13058070);
  assert(div_int(52232284, 4) == 13058071);
  assert(div_int(52232288, 4) == 13058072);
  assert(div_int(52232292, 4) == 13058073);
  assert(div_int(52232296, 4) == 13058074);
  assert(div_int(52232300, 4) == 13058075);
  assert(div_int(52232304, 4) == 13058076);
  assert(div_int(52232308, 4) == 13058077);
  assert(div_int(52232312, 4) == 13058078);
  assert(div_int(52232316, 4) == 13058079);
  assert(div_int(52232320, 4) == 13058080);
  assert(div_int(52232324, 4) == 13058081);
  assert(div_int(52232328, 4) == 13058082);
  assert(div_int(52232332, 4) == 13058083);
  assert(div_int(52232336, 4) == 13058084);
  assert(div_int(52232340, 4) == 13058085);
  assert(div_int(52232344, 4) == 13058086);
  assert(div_int(52232348, 4) == 13058087);
  assert(div_int(52232352, 4) == 13058088);
  assert(div_int(52232356, 4) == 13058089);
  assert(div_int(52232360, 4) == 13058090);
  assert(div_int(52232364, 4) == 13058091);
  assert(div_int(52232368, 4) == 13058092);
  assert(div_int(52232372, 4) == 13058093);
  assert(div_int(52232376, 4) == 13058094);
  assert(div_int(52232380, 4) == 13058095);
  assert(div_int(52232384, 4) == 13058096);
  assert(div_int(52232388, 4) == 13058097);
  assert(div_int(52232392, 4) == 13058098);
  assert(div_int(52232396, 4) == 13058099);
  assert(div_int(52232400, 4) == 13058100);
  assert(div_int(52232404, 4) == 13058101);
  assert(div_int(52232408, 4) == 13058102);
  assert(div_int(52232412, 4) == 13058103);
  assert(div_int(52232416, 4) == 13058104);
  assert(div_int(52232420, 4) == 13058105);
  assert(div_int(52232424, 4) == 13058106);
  assert(div_int(52232428, 4) == 13058107);
  assert(div_int(52232432, 4) == 13058108);
  assert(div_int(52232436, 4) == 13058109);
  assert(div_int(52232440, 4) == 13058110);
  assert(div_int(52232444, 4) == 13058111);
  assert(div_int(52232448, 4) == 13058112);
  assert(div_int(52232452, 4) == 13058113);
  assert(div_int(52232456, 4) == 13058114);
  assert(div_int(52232460, 4) == 13058115);
  assert(div_int(52232464, 4) == 13058116);
  assert(div_int(52232504, 4) == 13058126);
  assert(div_int(52232508, 4) == 13058127);
  assert(div_int(52232512, 4) == 13058128);
  assert(div_int(52232516, 4) == 13058129);
  assert(div_int(52232568, 4) == 13058142);
  assert(div_int(52232572, 4) == 13058143);
  assert(div_int(52232596, 4) == 13058149);
  assert(div_int(52232608, 8) == 6529076);
  assert(div_int(52232640, 8) == 6529080);
  assert(div_int(52232672, 8) == 6529084);
  assert(div_int(52232680, 8) == 6529085);
  assert(div_int(52232688, 8) == 6529086);
  assert(div_int(52232704, 8) == 6529088);
  assert(div_int(52232712, 8) == 6529089);
  assert(div_int(52232728, 8) == 6529091);
  assert(div_int(52232736, 8) == 6529092);
  assert(div_int(52232744, 8) == 6529093);
  assert(div_int(52232752, 8) == 6529094);
  assert(div_int(52232776, 8) == 6529097);
  assert(div_int(52232784, 8) == 6529098);
  assert(div_int(52232792, 8) == 6529099);
  assert(div_int(52232800, 8) == 6529100);
  assert(div_int(52232928, 4) == 13058232);
  assert(div_int(52232952, 8) == 6529119);
  assert(div_int(52232960, 8) == 6529120);
  assert(div_int(52232968, 8) == 6529121);
  assert(div_int(52232984, 8) == 6529123);
  assert(div_int(52232992, 8) == 6529124);
  assert(div_int(52233000, 8) == 6529125);
  assert(div_int(52233424, 4) == 13058356);
  assert(div_int(52233428, 4) == 13058357);
  assert(div_int(52233432, 4) == 13058358);
  assert(div_int(52233436, 4) == 13058359);
  assert(div_int(52233440, 4) == 13058360);
  assert(div_int(52233444, 4) == 13058361);
  assert(div_int(52233448, 4) == 13058362);
  assert(div_int(52233452, 4) == 13058363);
  assert(div_int(52233456, 4) == 13058364);
  assert(div_int(52233460, 4) == 13058365);
  assert(div_int(52233464, 4) == 13058366);
  assert(div_int(52233468, 4) == 13058367);
  assert(div_int(52233472, 4) == 13058368);
  assert(div_int(52233476, 4) == 13058369);
  assert(div_int(52233480, 4) == 13058370);
  assert(div_int(52233484, 4) == 13058371);
  assert(div_int(52233488, 4) == 13058372);
  assert(div_int(52233492, 4) == 13058373);
  assert(div_int(52233496, 4) == 13058374);
  assert(div_int(52233500, 4) == 13058375);
  assert(div_int(52233504, 4) == 13058376);
  assert(div_int(52233508, 4) == 13058377);
  assert(div_int(52233512, 4) == 13058378);
  assert(div_int(52233516, 4) == 13058379);
  assert(div_int(52233520, 4) == 13058380);
  assert(div_int(52233524, 4) == 13058381);
  assert(div_int(52233528, 4) == 13058382);
  assert(div_int(52233532, 4) == 13058383);
  assert(div_int(52233536, 4) == 13058384);
  assert(div_int(52233540, 4) == 13058385);
  assert(div_int(52233544, 4) == 13058386);
  assert(div_int(52233548, 4) == 13058387);
  assert(div_int(52233552, 4) == 13058388);
  assert(div_int(52233556, 4) == 13058389);
  assert(div_int(52233560, 4) == 13058390);
  assert(div_int(52233564, 4) == 13058391);
  assert(div_int(52233568, 4) == 13058392);
  assert(div_int(52233572, 4) == 13058393);
  assert(div_int(52233576, 4) == 13058394);
  assert(div_int(52233580, 4) == 13058395);
  assert(div_int(52233584, 4) == 13058396);
  assert(div_int(52233588, 4) == 13058397);
  assert(div_int(52233592, 4) == 13058398);
  assert(div_int(52233596, 4) == 13058399);
  assert(div_int(52233600, 4) == 13058400);
  assert(div_int(52233604, 4) == 13058401);
  assert(div_int(52233608, 4) == 13058402);
  assert(div_int(52233612, 4) == 13058403);
  assert(div_int(52233616, 4) == 13058404);
  assert(div_int(52233620, 4) == 13058405);
  assert(div_int(52233624, 4) == 13058406);
  assert(div_int(52233628, 4) == 13058407);
  assert(div_int(52233632, 4) == 13058408);
  assert(div_int(52233636, 4) == 13058409);
  assert(div_int(52233640, 4) == 13058410);
  assert(div_int(52233644, 4) == 13058411);
  assert(div_int(52233648, 4) == 13058412);
  assert(div_int(52233652, 4) == 13058413);
  assert(div_int(52233656, 4) == 13058414);
  assert(div_int(52233660, 4) == 13058415);
  assert(div_int(52233664, 4) == 13058416);
  assert(div_int(52233668, 4) == 13058417);
  assert(div_int(52233672, 4) == 13058418);
  assert(div_int(52233676, 4) == 13058419);
  assert(div_int(52233680, 4) == 13058420);
  assert(div_int(52233684, 4) == 13058421);
  assert(div_int(52233688, 4) == 13058422);
  assert(div_int(52233692, 4) == 13058423);
  assert(div_int(52233696, 4) == 13058424);
  assert(div_int(52233700, 4) == 13058425);
  assert(div_int(52233704, 4) == 13058426);
  assert(div_int(52233708, 4) == 13058427);
  assert(div_int(52233712, 4) == 13058428);
  assert(div_int(52233716, 4) == 13058429);
  assert(div_int(52233720, 4) == 13058430);
  assert(div_int(52233724, 4) == 13058431);
  assert(div_int(52233728, 4) == 13058432);
  assert(div_int(52233732, 4) == 13058433);
  assert(div_int(52233736, 4) == 13058434);
  assert(div_int(52233740, 4) == 13058435);
  assert(div_int(52233744, 4) == 13058436);
  assert(div_int(52233748, 4) == 13058437);
  assert(div_int(52233752, 4) == 13058438);
  assert(div_int(52233756, 4) == 13058439);
  assert(div_int(52233760, 4) == 13058440);
  assert(div_int(52233764, 4) == 13058441);
  assert(div_int(52233768, 4) == 13058442);
  assert(div_int(52233772, 4) == 13058443);
  assert(div_int(52233776, 4) == 13058444);
  assert(div_int(52233780, 4) == 13058445);
  assert(div_int(52233784, 4) == 13058446);
  assert(div_int(52233788, 4) == 13058447);
  assert(div_int(52233792, 4) == 13058448);
  assert(div_int(52233796, 4) == 13058449);
  assert(div_int(52233800, 4) == 13058450);
  assert(div_int(52233804, 4) == 13058451);
  assert(div_int(52233808, 4) == 13058452);
  assert(div_int(52233812, 4) == 13058453);
  assert(div_int(52233816, 4) == 13058454);
  assert(div_int(52233820, 4) == 13058455);
  assert(div_int(52233824, 4) == 13058456);
  assert(div_int(52233828, 4) == 13058457);
  assert(div_int(52233832, 4) == 13058458);
  assert(div_int(52233836, 4) == 13058459);
  assert(div_int(52233840, 4) == 13058460);
  assert(div_int(52233844, 4) == 13058461);
  assert(div_int(52233848, 4) == 13058462);
  assert(div_int(52233852, 4) == 13058463);
  assert(div_int(52233856, 4) == 13058464);
  assert(div_int(52233860, 4) == 13058465);
  assert(div_int(52233864, 4) == 13058466);
  assert(div_int(52233868, 4) == 13058467);
  assert(div_int(52233872, 4) == 13058468);
  assert(div_int(52233876, 4) == 13058469);
  assert(div_int(52233880, 4) == 13058470);
  assert(div_int(52233904, 4) == 13058476);
  assert(div_int(52233908, 4) == 13058477);
  assert(div_int(52233912, 4) == 13058478);
  assert(div_int(52233916, 4) == 13058479);
  assert(div_int(52233920, 4) == 13058480);
  assert(div_int(52233924, 4) == 13058481);
  assert(div_int(52233928, 4) == 13058482);
  assert(div_int(52233932, 4) == 13058483);
  assert(div_int(52233936, 4) == 13058484);
  assert(div_int(52233940, 4) == 13058485);
  assert(div_int(52233944, 4) == 13058486);
  assert(div_int(52233948, 4) == 13058487);
  assert(div_int(52233952, 4) == 13058488);
  assert(div_int(52233956, 4) == 13058489);
  assert(div_int(52233960, 4) == 13058490);
  assert(div_int(52233984, 4) == 13058496);
  assert(div_int(52233988, 4) == 13058497);
  assert(div_int(52233992, 4) == 13058498);
  assert(div_int(52233996, 4) == 13058499);
  assert(div_int(52234000, 4) == 13058500);
  assert(div_int(52234004, 4) == 13058501);
  assert(div_int(52234008, 4) == 13058502);
  assert(div_int(52234012, 4) == 13058503);
  assert(div_int(52234016, 4) == 13058504);
  assert(div_int(52234020, 4) == 13058505);
  assert(div_int(52234044, 4) == 13058511);
  assert(div_int(52234048, 4) == 13058512);
  assert(div_int(52234052, 4) == 13058513);
  assert(div_int(52234056, 4) == 13058514);
  assert(div_int(52234060, 4) == 13058515);
  assert(div_int(52234064, 4) == 13058516);
  assert(div_int(52234068, 4) == 13058517);
  assert(div_int(52234072, 4) == 13058518);
  assert(div_int(52234076, 4) == 13058519);
  assert(div_int(52234080, 4) == 13058520);
  assert(div_int(52234084, 4) == 13058521);
  assert(div_int(52234088, 4) == 13058522);
  assert(div_int(52234092, 4) == 13058523);
  assert(div_int(52234096, 4) == 13058524);
  assert(div_int(52234100, 4) == 13058525);
  assert(div_int(52234104, 4) == 13058526);
  assert(div_int(52234108, 4) == 13058527);
  assert(div_int(52234112, 4) == 13058528);
  assert(div_int(52234116, 4) == 13058529);
  assert(div_int(52234120, 4) == 13058530);
  assert(div_int(52234124, 4) == 13058531);
  assert(div_int(52234128, 4) == 13058532);
  assert(div_int(52234200, 4) == 13058550);
  assert(div_int(52234204, 4) == 13058551);
  assert(div_int(52234208, 4) == 13058552);
  assert(div_int(52234212, 4) == 13058553);
  assert(div_int(52234216, 4) == 13058554);
  assert(div_int(52234220, 4) == 13058555);
  assert(div_int(52234224, 4) == 13058556);
  assert(div_int(52234228, 4) == 13058557);
  assert(div_int(52234232, 4) == 13058558);
  assert(div_int(52234236, 4) == 13058559);
  assert(div_int(52234240, 4) == 13058560);
  assert(div_int(52234244, 4) == 13058561);
  assert(div_int(52234248, 4) == 13058562);
  assert(div_int(52234252, 4) == 13058563);
  assert(div_int(52234256, 4) == 13058564);
  assert(div_int(52234260, 4) == 13058565);
  assert(div_int(52234264, 4) == 13058566);
  assert(div_int(52234268, 4) == 13058567);
  assert(div_int(52234272, 4) == 13058568);
  assert(div_int(52234276, 4) == 13058569);
  assert(div_int(52234280, 4) == 13058570);
  assert(div_int(52234284, 4) == 13058571);
  assert(div_int(52234288, 4) == 13058572);
  assert(div_int(52234292, 4) == 13058573);
  assert(div_int(52234296, 4) == 13058574);
  assert(div_int(52234300, 4) == 13058575);
  assert(div_int(52234304, 4) == 13058576);
  assert(div_int(52234308, 4) == 13058577);
  assert(div_int(52234312, 4) == 13058578);
  assert(div_int(52234316, 4) == 13058579);
  assert(div_int(52234320, 4) == 13058580);
  assert(div_int(52234324, 4) == 13058581);
  assert(div_int(52234328, 4) == 13058582);
  assert(div_int(52234332, 4) == 13058583);
  assert(div_int(52234336, 4) == 13058584);
  assert(div_int(52234340, 4) == 13058585);
  assert(div_int(52234344, 4) == 13058586);
  assert(div_int(52234348, 4) == 13058587);
  assert(div_int(52234352, 4) == 13058588);
  assert(div_int(52234356, 4) == 13058589);
  assert(div_int(52234384, 8) == 6529298);
  assert(div_int(52234392, 8) == 6529299);
  assert(div_int(52234400, 8) == 6529300);
  assert(div_int(52234408, 4) == 13058602);
  assert(div_int(52234412, 4) == 13058603);
  assert(div_int(52234416, 4) == 13058604);
  assert(div_int(52234420, 4) == 13058605);
  assert(div_int(52234424, 4) == 13058606);
  assert(div_int(52234428, 4) == 13058607);
  assert(div_int(52234432, 4) == 13058608);
  assert(div_int(52234436, 4) == 13058609);
  assert(div_int(52234440, 4) == 13058610);
  assert(div_int(52234444, 4) == 13058611);
  assert(div_int(52234448, 4) == 13058612);
  assert(div_int(52234452, 4) == 13058613);
  assert(div_int(52234456, 4) == 13058614);
  assert(div_int(52234460, 4) == 13058615);
  assert(div_int(52234464, 4) == 13058616);
  assert(div_int(52234468, 4) == 13058617);
  assert(div_int(52234472, 4) == 13058618);
  assert(div_int(52234476, 4) == 13058619);
  assert(div_int(52234480, 4) == 13058620);
  assert(div_int(52234484, 4) == 13058621);
  assert(div_int(52234492, 4) == 13058623);
  assert(div_int(52234496, 4) == 13058624);
  assert(div_int(52234500, 4) == 13058625);
  assert(div_int(52234504, 4) == 13058626);
  assert(div_int(52234508, 4) == 13058627);
  assert(div_int(52234512, 4) == 13058628);
  assert(div_int(52234516, 4) == 13058629);
  assert(div_int(52234520, 4) == 13058630);
  assert(div_int(52234524, 4) == 13058631);
  assert(div_int(52234528, 4) == 13058632);
  assert(div_int(52234532, 4) == 13058633);
  assert(div_int(52234536, 4) == 13058634);
  assert(div_int(52234540, 4) == 13058635);
  assert(div_int(52234544, 4) == 13058636);
  assert(div_int(52234548, 4) == 13058637);
  assert(div_int(52234552, 4) == 13058638);
  assert(div_int(52234556, 4) == 13058639);
  assert(div_int(52234560, 4) == 13058640);
  assert(div_int(52234564, 4) == 13058641);
  assert(div_int(52234568, 4) == 13058642);
  assert(div_int(52234572, 4) == 13058643);
  assert(div_int(52234576, 4) == 13058644);
  assert(div_int(52234580, 4) == 13058645);
  assert(div_int(52234584, 4) == 13058646);
  assert(div_int(52234588, 4) == 13058647);
  assert(div_int(52234592, 4) == 13058648);
  assert(div_int(52234596, 4) == 13058649);
  assert(div_int(52234600, 4) == 13058650);
  assert(div_int(52234604, 4) == 13058651);
  assert(div_int(52234608, 4) == 13058652);
  assert(div_int(52234612, 4) == 13058653);
  assert(div_int(52234616, 4) == 13058654);
  assert(div_int(52234620, 4) == 13058655);
  assert(div_int(52234624, 4) == 13058656);
  assert(div_int(52234628, 4) == 13058657);
  assert(div_int(52234632, 4) == 13058658);
  assert(div_int(52234636, 4) == 13058659);
  assert(div_int(52234640, 4) == 13058660);
  assert(div_int(52234644, 4) == 13058661);
  assert(div_int(52234648, 4) == 13058662);
  assert(div_int(52234652, 4) == 13058663);
  assert(div_int(52234656, 4) == 13058664);
  assert(div_int(52234660, 4) == 13058665);
  assert(div_int(52234664, 4) == 13058666);
  assert(div_int(52234668, 4) == 13058667);
  assert(div_int(52234672, 4) == 13058668);
  assert(div_int(52234676, 4) == 13058669);
  assert(div_int(52234680, 4) == 13058670);
  assert(div_int(52234684, 4) == 13058671);
  assert(div_int(52234688, 4) == 13058672);
  assert(div_int(52234692, 4) == 13058673);
  assert(div_int(52234696, 4) == 13058674);
  assert(div_int(52234700, 4) == 13058675);
  assert(div_int(52234704, 4) == 13058676);
  assert(div_int(52234708, 4) == 13058677);
  assert(div_int(52234716, 4) == 13058679);
  assert(div_int(52234720, 4) == 13058680);
  assert(div_int(52234724, 4) == 13058681);
  assert(div_int(52234728, 4) == 13058682);
  assert(div_int(52234732, 4) == 13058683);
  assert(div_int(52234736, 4) == 13058684);
  assert(div_int(52234740, 4) == 13058685);
  assert(div_int(52234744, 4) == 13058686);
  assert(div_int(52234748, 4) == 13058687);
  assert(div_int(52234760, 4) == 13058690);
  assert(div_int(52234764, 4) == 13058691);
  assert(div_int(52234768, 4) == 13058692);
  assert(div_int(52234772, 4) == 13058693);
  assert(div_int(52234776, 4) == 13058694);
  assert(div_int(52234780, 4) == 13058695);
  assert(div_int(52234784, 4) == 13058696);
  assert(div_int(52234788, 4) == 13058697);
  assert(div_int(52234792, 4) == 13058698);
  assert(div_int(52234796, 4) == 13058699);
  assert(div_int(52234800, 4) == 13058700);
  assert(div_int(52234804, 4) == 13058701);
  assert(div_int(52234808, 4) == 13058702);
  assert(div_int(52234812, 4) == 13058703);
  assert(div_int(52234816, 4) == 13058704);
  assert(div_int(52234820, 4) == 13058705);
  assert(div_int(52234824, 4) == 13058706);
  assert(div_int(52234828, 4) == 13058707);
  assert(div_int(52234832, 4) == 13058708);
  assert(div_int(52234836, 4) == 13058709);
  assert(div_int(52234840, 4) == 13058710);
  assert(div_int(52234844, 4) == 13058711);
  assert(div_int(52234848, 4) == 13058712);
  assert(div_int(52234852, 4) == 13058713);
  assert(div_int(52234856, 4) == 13058714);
  assert(div_int(52234860, 4) == 13058715);
  assert(div_int(52234864, 4) == 13058716);
  assert(div_int(52234868, 4) == 13058717);
  assert(div_int(52234872, 4) == 13058718);
  assert(div_int(52234876, 4) == 13058719);
  assert(div_int(52234880, 4) == 13058720);
  assert(div_int(52234884, 4) == 13058721);
  assert(div_int(52234888, 4) == 13058722);
  assert(div_int(52234892, 4) == 13058723);
  assert(div_int(52234896, 4) == 13058724);
  assert(div_int(52234900, 4) == 13058725);
  assert(div_int(52234904, 4) == 13058726);
  assert(div_int(52234908, 4) == 13058727);
  assert(div_int(52234912, 4) == 13058728);
  assert(div_int(52234916, 4) == 13058729);
  assert(div_int(52234920, 4) == 13058730);
  assert(div_int(52234924, 4) == 13058731);
  assert(div_int(52234928, 4) == 13058732);
  assert(div_int(52234932, 4) == 13058733);
  assert(div_int(52234936, 4) == 13058734);
  assert(div_int(52234940, 4) == 13058735);
  assert(div_int(52234944, 4) == 13058736);
  assert(div_int(52234948, 4) == 13058737);
  assert(div_int(52234952, 4) == 13058738);
  assert(div_int(52234956, 4) == 13058739);
  assert(div_int(52234960, 4) == 13058740);
  assert(div_int(52234964, 4) == 13058741);
  assert(div_int(52234968, 4) == 13058742);
  assert(div_int(52234972, 4) == 13058743);
  assert(div_int(52234976, 4) == 13058744);
  assert(div_int(52234980, 4) == 13058745);
  assert(div_int(52234984, 4) == 13058746);
  assert(div_int(52234988, 4) == 13058747);
  assert(div_int(52234992, 4) == 13058748);
  assert(div_int(52234996, 4) == 13058749);
  assert(div_int(52235000, 4) == 13058750);
  assert(div_int(52235016, 4) == 13058754);
  assert(div_int(52235020, 4) == 13058755);
  assert(div_int(52235024, 4) == 13058756);
  assert(div_int(52235028, 4) == 13058757);
  assert(div_int(52235032, 4) == 13058758);
  assert(div_int(52235036, 4) == 13058759);
  assert(div_int(52235040, 4) == 13058760);
  assert(div_int(52235044, 4) == 13058761);
  assert(div_int(52235048, 4) == 13058762);
  assert(div_int(52235060, 4) == 13058765);
  assert(div_int(52235064, 4) == 13058766);
  assert(div_int(52235068, 4) == 13058767);
  assert(div_int(52235072, 4) == 13058768);
  assert(div_int(52235088, 4) == 13058772);
  assert(div_int(52235092, 4) == 13058773);
  assert(div_int(52235096, 4) == 13058774);
  assert(div_int(52235100, 4) == 13058775);
  assert(div_int(52235104, 4) == 13058776);
  assert(div_int(52235108, 4) == 13058777);
  assert(div_int(52235112, 4) == 13058778);
  assert(div_int(52235116, 4) == 13058779);
  assert(div_int(52235120, 4) == 13058780);
  assert(div_int(52235124, 4) == 13058781);
  assert(div_int(52235128, 4) == 13058782);
  assert(div_int(52235132, 4) == 13058783);
  assert(div_int(52235136, 4) == 13058784);
  assert(div_int(52235140, 4) == 13058785);
  assert(div_int(52235144, 4) == 13058786);
  assert(div_int(52235148, 4) == 13058787);
  assert(div_int(52235152, 4) == 13058788);
  assert(div_int(52235156, 4) == 13058789);
  assert(div_int(52235160, 4) == 13058790);
  assert(div_int(52235164, 4) == 13058791);
  assert(div_int(52235168, 4) == 13058792);
  assert(div_int(52235172, 4) == 13058793);
  assert(div_int(52235176, 4) == 13058794);
  assert(div_int(52235180, 4) == 13058795);
  assert(div_int(52235184, 4) == 13058796);
  assert(div_int(52235188, 4) == 13058797);
  assert(div_int(52235192, 4) == 13058798);
  assert(div_int(52235196, 4) == 13058799);
  assert(div_int(52235200, 4) == 13058800);
  assert(div_int(52235204, 4) == 13058801);
  assert(div_int(52235208, 4) == 13058802);
  assert(div_int(52235212, 4) == 13058803);
  assert(div_int(52235216, 4) == 13058804);
  assert(div_int(52235220, 4) == 13058805);
  assert(div_int(52235224, 4) == 13058806);
  assert(div_int(52235228, 4) == 13058807);
  assert(div_int(52235232, 4) == 13058808);
  assert(div_int(52235236, 4) == 13058809);
  assert(div_int(52235240, 4) == 13058810);
  assert(div_int(52235244, 4) == 13058811);
  assert(div_int(52235248, 4) == 13058812);
  assert(div_int(52235252, 4) == 13058813);
  assert(div_int(52235256, 4) == 13058814);
  assert(div_int(52235260, 4) == 13058815);
  assert(div_int(52235264, 4) == 13058816);
  assert(div_int(52235268, 4) == 13058817);
  assert(div_int(52235272, 4) == 13058818);
  assert(div_int(52235276, 4) == 13058819);
  assert(div_int(52235292, 4) == 13058823);
  assert(div_int(52235296, 4) == 13058824);
  assert(div_int(52235300, 4) == 13058825);
  assert(div_int(52235304, 4) == 13058826);
  assert(div_int(52235308, 4) == 13058827);
  assert(div_int(52235312, 4) == 13058828);
  assert(div_int(52235316, 4) == 13058829);
  assert(div_int(52235320, 4) == 13058830);
  assert(div_int(52235324, 4) == 13058831);
  assert(div_int(52235336, 4) == 13058834);
  assert(div_int(52235340, 4) == 13058835);
  assert(div_int(52235344, 4) == 13058836);
  assert(div_int(52235348, 4) == 13058837);
  assert(div_int(52235364, 4) == 13058841);
  assert(div_int(52235368, 4) == 13058842);
  assert(div_int(52235372, 4) == 13058843);
  assert(div_int(52235376, 4) == 13058844);
  assert(div_int(52235380, 4) == 13058845);
  assert(div_int(52235384, 4) == 13058846);
  assert(div_int(52235388, 4) == 13058847);
  assert(div_int(52235392, 4) == 13058848);
  assert(div_int(52235396, 4) == 13058849);
  assert(div_int(52235400, 4) == 13058850);
  assert(div_int(52235404, 4) == 13058851);
  assert(div_int(52235408, 4) == 13058852);
  assert(div_int(52235412, 4) == 13058853);
  assert(div_int(52235416, 4) == 13058854);
  assert(div_int(52235420, 4) == 13058855);
  assert(div_int(52235424, 4) == 13058856);
  assert(div_int(52235428, 4) == 13058857);
  assert(div_int(52235432, 4) == 13058858);
  assert(div_int(52235436, 4) == 13058859);
  assert(div_int(52235440, 4) == 13058860);
  assert(div_int(52235444, 4) == 13058861);
  assert(div_int(52235448, 4) == 13058862);
  assert(div_int(52235452, 4) == 13058863);
  assert(div_int(52235456, 4) == 13058864);
  assert(div_int(52235460, 4) == 13058865);
  assert(div_int(52235464, 4) == 13058866);
  assert(div_int(52235468, 4) == 13058867);
  assert(div_int(52235472, 4) == 13058868);
  assert(div_int(52235476, 4) == 13058869);
  assert(div_int(52235480, 4) == 13058870);
  assert(div_int(52235484, 4) == 13058871);
  assert(div_int(52235488, 4) == 13058872);
  assert(div_int(52235492, 4) == 13058873);
  assert(div_int(52235496, 4) == 13058874);
  assert(div_int(52235500, 4) == 13058875);
  assert(div_int(52235504, 4) == 13058876);
  assert(div_int(52235508, 4) == 13058877);
  assert(div_int(52235512, 4) == 13058878);
  assert(div_int(52235516, 4) == 13058879);
  assert(div_int(52235520, 4) == 13058880);
  assert(div_int(52235524, 4) == 13058881);
  assert(div_int(52235528, 4) == 13058882);
  assert(div_int(52235532, 4) == 13058883);
  assert(div_int(52235536, 4) == 13058884);
  assert(div_int(52235540, 4) == 13058885);
  assert(div_int(52235556, 4) == 13058889);
  assert(div_int(52235560, 4) == 13058890);
  assert(div_int(52235564, 4) == 13058891);
  assert(div_int(52235568, 4) == 13058892);
  assert(div_int(52235572, 4) == 13058893);
  assert(div_int(52235576, 4) == 13058894);
  assert(div_int(52235580, 4) == 13058895);
  assert(div_int(52235592, 4) == 13058898);
  assert(div_int(52235596, 4) == 13058899);
  assert(div_int(52235600, 4) == 13058900);
  assert(div_int(52235604, 4) == 13058901);
  assert(div_int(52235620, 4) == 13058905);
  assert(div_int(52235624, 4) == 13058906);
  assert(div_int(52235628, 4) == 13058907);
  assert(div_int(52235632, 4) == 13058908);
  assert(div_int(52235636, 4) == 13058909);
  assert(div_int(52235640, 4) == 13058910);
  assert(div_int(52235644, 4) == 13058911);
  assert(div_int(52235648, 4) == 13058912);
  assert(div_int(52235652, 4) == 13058913);
  assert(div_int(52235656, 4) == 13058914);
  assert(div_int(52235660, 4) == 13058915);
  assert(div_int(52235664, 4) == 13058916);
  assert(div_int(52235668, 4) == 13058917);
  assert(div_int(52235672, 4) == 13058918);
  assert(div_int(52235676, 4) == 13058919);
  assert(div_int(52235680, 4) == 13058920);
  assert(div_int(52235684, 4) == 13058921);
  assert(div_int(52235688, 4) == 13058922);
  assert(div_int(52235692, 4) == 13058923);
  assert(div_int(52235696, 4) == 13058924);
  assert(div_int(52235700, 4) == 13058925);
  assert(div_int(52235704, 4) == 13058926);
  assert(div_int(52235708, 4) == 13058927);
  assert(div_int(52235712, 4) == 13058928);
  assert(div_int(52235716, 4) == 13058929);
  assert(div_int(52235720, 4) == 13058930);
  assert(div_int(52235724, 4) == 13058931);
  assert(div_int(52235728, 4) == 13058932);
  assert(div_int(52235732, 4) == 13058933);
  assert(div_int(52235736, 4) == 13058934);
  assert(div_int(52235740, 4) == 13058935);
  assert(div_int(52235744, 4) == 13058936);
  assert(div_int(52235748, 4) == 13058937);
  assert(div_int(52235752, 4) == 13058938);
  assert(div_int(52235756, 4) == 13058939);
  assert(div_int(52235760, 4) == 13058940);
  assert(div_int(52235764, 4) == 13058941);
  assert(div_int(52235768, 4) == 13058942);
  assert(div_int(52235772, 4) == 13058943);
  assert(div_int(52235776, 4) == 13058944);
  assert(div_int(52235780, 4) == 13058945);
  assert(div_int(52235784, 4) == 13058946);
  assert(div_int(52235788, 4) == 13058947);
  assert(div_int(52235792, 4) == 13058948);
  assert(div_int(52235796, 4) == 13058949);
  assert(div_int(52235800, 4) == 13058950);
  assert(div_int(52235804, 4) == 13058951);
  assert(div_int(52235808, 4) == 13058952);
  assert(div_int(52235812, 4) == 13058953);
  assert(div_int(52235816, 4) == 13058954);
  assert(div_int(52235820, 4) == 13058955);
  assert(div_int(52235824, 4) == 13058956);
  assert(div_int(52235828, 4) == 13058957);
  assert(div_int(52235832, 4) == 13058958);
  assert(div_int(52235840, 8) == 6529480);
  assert(div_int(52235848, 8) == 6529481);
  assert(div_int(52235856, 8) == 6529482);
  assert(div_int(52235864, 4) == 13058966);
  assert(div_int(52235868, 4) == 13058967);
  assert(div_int(52235872, 4) == 13058968);
  assert(div_int(52235876, 4) == 13058969);
  assert(div_int(52235880, 4) == 13058970);
  assert(div_int(52235884, 4) == 13058971);
  assert(div_int(52235888, 4) == 13058972);
  assert(div_int(52235892, 4) == 13058973);
  assert(div_int(52235896, 4) == 13058974);
  assert(div_int(52235900, 4) == 13058975);
  assert(div_int(52235904, 4) == 13058976);
  assert(div_int(52235908, 4) == 13058977);
  assert(div_int(52235912, 4) == 13058978);
  assert(div_int(52235916, 4) == 13058979);
  assert(div_int(52236092, 4) == 13059023);
  assert(div_int(52236096, 4) == 13059024);
  assert(div_int(52236100, 4) == 13059025);
  assert(div_int(52236104, 4) == 13059026);
  assert(div_int(52236108, 4) == 13059027);
  assert(div_int(52236112, 4) == 13059028);
  assert(div_int(52236116, 4) == 13059029);
  assert(div_int(52236120, 4) == 13059030);
  assert(div_int(52236124, 4) == 13059031);
  assert(div_int(52236128, 4) == 13059032);
  assert(div_int(52236132, 4) == 13059033);
  assert(div_int(52236136, 4) == 13059034);
  assert(div_int(52236140, 4) == 13059035);
  assert(div_int(52236144, 4) == 13059036);
  assert(div_int(52236148, 4) == 13059037);
  assert(div_int(52236152, 4) == 13059038);
  assert(div_int(52236156, 4) == 13059039);
  assert(div_int(52236172, 4) == 13059043);
  assert(div_int(52236176, 4) == 13059044);
  assert(div_int(52236180, 4) == 13059045);
  assert(div_int(52236184, 4) == 13059046);
  assert(div_int(52236188, 4) == 13059047);
  assert(div_int(52236192, 4) == 13059048);
  assert(div_int(52236208, 4) == 13059052);
  assert(div_int(52236212, 4) == 13059053);
  assert(div_int(52236216, 4) == 13059054);
  assert(div_int(52236220, 4) == 13059055);
  assert(div_int(52236224, 4) == 13059056);
  assert(div_int(52236228, 4) == 13059057);
  assert(div_int(52236380, 4) == 13059095);
  assert(div_int(52236384, 4) == 13059096);
  assert(div_int(52236388, 4) == 13059097);
  assert(div_int(52236392, 4) == 13059098);
  assert(div_int(52236396, 4) == 13059099);
  assert(div_int(52236408, 4) == 13059102);
  assert(div_int(52236412, 4) == 13059103);
  assert(div_int(52236416, 4) == 13059104);
  assert(div_int(52236420, 4) == 13059105);
  assert(div_int(52236424, 4) == 13059106);
  assert(div_int(52236428, 4) == 13059107);
  assert(div_int(52236432, 4) == 13059108);
  assert(div_int(52236436, 4) == 13059109);
  assert(div_int(52236448, 4) == 13059112);
  assert(div_int(52236452, 4) == 13059113);
  assert(div_int(52236456, 8) == 6529557);
  assert(div_int(52236464, 8) == 6529558);
  assert(div_int(52236472, 4) == 13059118);
  assert(div_int(52236476, 4) == 13059119);
  assert(div_int(52236480, 4) == 13059120);
  assert(div_int(52236484, 4) == 13059121);
  assert(div_int(52236488, 4) == 13059122);
  assert(div_int(52236492, 4) == 13059123);
  assert(div_int(52236496, 4) == 13059124);
  assert(div_int(52236500, 4) == 13059125);
  assert(div_int(52236504, 4) == 13059126);
  assert(div_int(52236508, 4) == 13059127);
  assert(div_int(52236512, 4) == 13059128);
  assert(div_int(52236516, 4) == 13059129);
  assert(div_int(52236520, 4) == 13059130);
  assert(div_int(52236524, 4) == 13059131);
  assert(div_int(52236528, 4) == 13059132);
  assert(div_int(52236532, 4) == 13059133);
  assert(div_int(52236536, 8) == 6529567);
  assert(div_int(52236544, 8) == 6529568);
  assert(div_int(52236552, 8) == 6529569);
  assert(div_int(52236560, 8) == 6529570);
  assert(div_int(52236568, 4) == 13059142);
  assert(div_int(52236572, 4) == 13059143);
  assert(div_int(52236576, 4) == 13059144);
  assert(div_int(52236580, 4) == 13059145);
  assert(div_int(52236584, 4) == 13059146);
  assert(div_int(52236588, 4) == 13059147);
  assert(div_int(52236592, 4) == 13059148);
  assert(div_int(52236596, 4) == 13059149);
  assert(div_int(52236600, 4) == 13059150);
  assert(div_int(52236604, 4) == 13059151);
  assert(div_int(52236608, 4) == 13059152);
  assert(div_int(52236612, 4) == 13059153);
  assert(div_int(52236616, 4) == 13059154);
  assert(div_int(52236620, 4) == 13059155);
  assert(div_int(52236624, 4) == 13059156);
  assert(div_int(52236628, 4) == 13059157);
  assert(div_int(52236632, 4) == 13059158);
  assert(div_int(52236636, 4) == 13059159);
  assert(div_int(52236640, 4) == 13059160);
  assert(div_int(52236644, 4) == 13059161);
  assert(div_int(52236648, 8) == 6529581);
  assert(div_int(52236656, 8) == 6529582);
  assert(div_int(52236664, 8) == 6529583);
  assert(div_int(52236672, 4) == 13059168);
  assert(div_int(52236676, 4) == 13059169);
  assert(div_int(52236680, 4) == 13059170);
  assert(div_int(52236684, 4) == 13059171);
  assert(div_int(52236688, 4) == 13059172);
  assert(div_int(52236692, 4) == 13059173);
  assert(div_int(52236696, 4) == 13059174);
  assert(div_int(52236700, 4) == 13059175);
  assert(div_int(52236704, 4) == 13059176);
  assert(div_int(52236708, 4) == 13059177);
  assert(div_int(52236712, 4) == 13059178);
  assert(div_int(52236716, 4) == 13059179);
  assert(div_int(52236720, 4) == 13059180);
  assert(div_int(52236724, 4) == 13059181);
  assert(div_int(52236728, 4) == 13059182);
  assert(div_int(52236732, 4) == 13059183);
  assert(div_int(52236736, 4) == 13059184);
  assert(div_int(52236740, 4) == 13059185);
  assert(div_int(52236744, 4) == 13059186);
  assert(div_int(52236748, 4) == 13059187);
  assert(div_int(52236752, 4) == 13059188);
  assert(div_int(52236756, 4) == 13059189);
  assert(div_int(52236760, 4) == 13059190);
  assert(div_int(52236764, 4) == 13059191);
  assert(div_int(52236768, 4) == 13059192);
  assert(div_int(52236780, 4) == 13059195);
  assert(div_int(52236784, 4) == 13059196);
  assert(div_int(52236792, 4) == 13059198);
  assert(div_int(52236796, 4) == 13059199);
  assert(div_int(52236800, 4) == 13059200);
  assert(div_int(52236804, 4) == 13059201);
  assert(div_int(52236808, 4) == 13059202);
  assert(div_int(52236812, 4) == 13059203);
  assert(div_int(52236832, 4) == 13059208);
  assert(div_int(52236836, 4) == 13059209);
  assert(div_int(52236884, 4) == 13059221);
  assert(div_int(52236888, 4) == 13059222);
  assert(div_int(52236892, 4) == 13059223);
  assert(div_int(52236956, 4) == 13059239);
  assert(div_int(52236960, 4) == 13059240);
  assert(div_int(52236964, 4) == 13059241);
  assert(div_int(52236968, 4) == 13059242);
  assert(div_int(52236972, 4) == 13059243);
  assert(div_int(52236976, 4) == 13059244);
  assert(div_int(52236980, 4) == 13059245);
  assert(div_int(52236984, 4) == 13059246);
  assert(div_int(52236988, 4) == 13059247);
  assert(div_int(52236992, 4) == 13059248);
  assert(div_int(52236996, 4) == 13059249);
  assert(div_int(52237000, 4) == 13059250);
  assert(div_int(52237004, 4) == 13059251);
  assert(div_int(52237008, 4) == 13059252);
  assert(div_int(52237012, 4) == 13059253);
  assert(div_int(52237016, 4) == 13059254);
  assert(div_int(52237020, 4) == 13059255);
  assert(div_int(52237024, 4) == 13059256);
  assert(div_int(52237028, 4) == 13059257);
  assert(div_int(52237032, 4) == 13059258);
  assert(div_int(52237036, 4) == 13059259);
  assert(div_int(52237040, 4) == 13059260);
  assert(div_int(52237044, 4) == 13059261);
  assert(div_int(52237048, 4) == 13059262);
  assert(div_int(52237052, 4) == 13059263);
  assert(div_int(52237056, 4) == 13059264);
  assert(div_int(52237060, 4) == 13059265);
  assert(div_int(52237064, 4) == 13059266);
  assert(div_int(52237068, 4) == 13059267);
  assert(div_int(52237072, 4) == 13059268);
  assert(div_int(52237076, 4) == 13059269);
  assert(div_int(52237080, 4) == 13059270);
  assert(div_int(52237084, 4) == 13059271);
  assert(div_int(52237088, 4) == 13059272);
  assert(div_int(52237092, 4) == 13059273);
  assert(div_int(52237096, 4) == 13059274);
  assert(div_int(52237100, 4) == 13059275);
  assert(div_int(52237104, 4) == 13059276);
  assert(div_int(52237108, 4) == 13059277);
  assert(div_int(52237112, 4) == 13059278);
  assert(div_int(52237116, 4) == 13059279);
  assert(div_int(52237120, 4) == 13059280);
  assert(div_int(52237124, 4) == 13059281);
  assert(div_int(52237128, 4) == 13059282);
  assert(div_int(52237132, 4) == 13059283);
  assert(div_int(52237136, 4) == 13059284);
  assert(div_int(52237140, 4) == 13059285);
  assert(div_int(52237144, 4) == 13059286);
  assert(div_int(52237148, 4) == 13059287);
  assert(div_int(52237152, 4) == 13059288);
  assert(div_int(52237156, 4) == 13059289);
  assert(div_int(52237160, 4) == 13059290);
  assert(div_int(52237164, 4) == 13059291);
  assert(div_int(52237168, 4) == 13059292);
  assert(div_int(52237172, 4) == 13059293);
  assert(div_int(52237176, 4) == 13059294);
  assert(div_int(52237180, 4) == 13059295);
  assert(div_int(52237184, 4) == 13059296);
  assert(div_int(52237188, 4) == 13059297);
  assert(div_int(52237192, 4) == 13059298);
  assert(div_int(52237200, 8) == 6529650);
  assert(div_int(52237208, 8) == 6529651);
  assert(div_int(52237216, 8) == 6529652);
  assert(div_int(52237224, 8) == 6529653);
  assert(div_int(52237232, 8) == 6529654);
  assert(div_int(52237240, 8) == 6529655);
  assert(div_int(52237248, 8) == 6529656);
  assert(div_int(52237256, 8) == 6529657);
  assert(div_int(52237264, 8) == 6529658);
  assert(div_int(52237272, 8) == 6529659);
  assert(div_int(52237280, 8) == 6529660);
  assert(div_int(52237288, 8) == 6529661);
  assert(div_int(52237296, 8) == 6529662);
  assert(div_int(52237304, 8) == 6529663);
  assert(div_int(52237312, 8) == 6529664);
  assert(div_int(52237320, 8) == 6529665);
  assert(div_int(52237328, 8) == 6529666);
  assert(div_int(52237336, 8) == 6529667);
  assert(div_int(52237344, 8) == 6529668);
  assert(div_int(52237352, 8) == 6529669);
  assert(div_int(52237360, 8) == 6529670);
  assert(div_int(52237368, 8) == 6529671);
  assert(div_int(52237376, 8) == 6529672);
  assert(div_int(52237384, 8) == 6529673);
  assert(div_int(52237392, 8) == 6529674);
  assert(div_int(52237400, 8) == 6529675);
  assert(div_int(52237408, 8) == 6529676);
  assert(div_int(52237416, 8) == 6529677);
  assert(div_int(52237424, 8) == 6529678);
  assert(div_int(52237432, 8) == 6529679);
  assert(div_int(52237440, 8) == 6529680);
  assert(div_int(52237448, 8) == 6529681);
  assert(div_int(52237456, 8) == 6529682);
  assert(div_int(52237464, 8) == 6529683);
  assert(div_int(52237472, 8) == 6529684);
  assert(div_int(52237480, 8) == 6529685);
  assert(div_int(52237488, 8) == 6529686);
  assert(div_int(52237496, 8) == 6529687);
  assert(div_int(52237504, 8) == 6529688);
  assert(div_int(52237512, 8) == 6529689);
  assert(div_int(52237520, 8) == 6529690);
  assert(div_int(52237528, 8) == 6529691);
  assert(div_int(52237536, 8) == 6529692);
  assert(div_int(52237544, 8) == 6529693);
  assert(div_int(52237552, 8) == 6529694);
  assert(div_int(52237560, 8) == 6529695);
  assert(div_int(52237568, 8) == 6529696);
  assert(div_int(52237576, 8) == 6529697);
  assert(div_int(52237584, 8) == 6529698);
  assert(div_int(52237592, 8) == 6529699);
  assert(div_int(52237600, 8) == 6529700);
  assert(div_int(52237608, 8) == 6529701);
  assert(div_int(52237616, 8) == 6529702);
  assert(div_int(52237624, 8) == 6529703);
  assert(div_int(52237632, 8) == 6529704);
  assert(div_int(52237640, 8) == 6529705);
  assert(div_int(52237648, 8) == 6529706);
  assert(div_int(52237656, 8) == 6529707);
  assert(div_int(52237664, 8) == 6529708);
  assert(div_int(52237672, 8) == 6529709);
  assert(div_int(52237680, 8) == 6529710);
  assert(div_int(52237688, 8) == 6529711);
  assert(div_int(52237696, 8) == 6529712);
  assert(div_int(52237704, 8) == 6529713);
  assert(div_int(52237712, 8) == 6529714);
  assert(div_int(52237720, 8) == 6529715);
  assert(div_int(52237728, 8) == 6529716);
  assert(div_int(52237736, 8) == 6529717);
  assert(div_int(52237744, 8) == 6529718);
  assert(div_int(52237752, 8) == 6529719);
  assert(div_int(52237760, 8) == 6529720);
  assert(div_int(52237768, 8) == 6529721);
  assert(div_int(52237776, 8) == 6529722);
  assert(div_int(52237784, 8) == 6529723);
  assert(div_int(52237792, 8) == 6529724);
  assert(div_int(52237800, 8) == 6529725);
  assert(div_int(52237808, 8) == 6529726);
  assert(div_int(52237816, 8) == 6529727);
  assert(div_int(52237824, 8) == 6529728);
  assert(div_int(52237832, 8) == 6529729);
  assert(div_int(52237840, 8) == 6529730);
  assert(div_int(52237848, 8) == 6529731);
  assert(div_int(52237856, 8) == 6529732);
  assert(div_int(52237864, 8) == 6529733);
  assert(div_int(52237872, 8) == 6529734);
  assert(div_int(52237880, 8) == 6529735);
  assert(div_int(52237888, 8) == 6529736);
  assert(div_int(52237896, 8) == 6529737);
  assert(div_int(52237904, 8) == 6529738);
  assert(div_int(52237912, 8) == 6529739);
  assert(div_int(52237920, 8) == 6529740);
  assert(div_int(52237928, 8) == 6529741);
  assert(div_int(52237936, 8) == 6529742);
  assert(div_int(52237944, 8) == 6529743);
  assert(div_int(52237952, 8) == 6529744);
  assert(div_int(52237960, 8) == 6529745);
  assert(div_int(52237968, 8) == 6529746);
  assert(div_int(52237976, 8) == 6529747);
  assert(div_int(52237984, 8) == 6529748);
  assert(div_int(52237992, 8) == 6529749);
  assert(div_int(52238000, 8) == 6529750);
  assert(div_int(52238008, 8) == 6529751);
  assert(div_int(52238016, 8) == 6529752);
  assert(div_int(52238024, 8) == 6529753);
  assert(div_int(52238032, 8) == 6529754);
  assert(div_int(52238040, 8) == 6529755);
  assert(div_int(52238048, 8) == 6529756);
  assert(div_int(52238056, 8) == 6529757);
  assert(div_int(52238064, 8) == 6529758);
  assert(div_int(52238072, 8) == 6529759);
  assert(div_int(52238080, 8) == 6529760);
  assert(div_int(52238088, 8) == 6529761);
  assert(div_int(52238096, 8) == 6529762);
  assert(div_int(52238104, 8) == 6529763);
  assert(div_int(52238112, 8) == 6529764);
  assert(div_int(52238120, 8) == 6529765);
  assert(div_int(52238128, 8) == 6529766);
  assert(div_int(52238136, 8) == 6529767);
  assert(div_int(52238144, 8) == 6529768);
  assert(div_int(52238152, 8) == 6529769);
  assert(div_int(52238160, 8) == 6529770);
  assert(div_int(52238168, 8) == 6529771);
  assert(div_int(52238176, 8) == 6529772);
  assert(div_int(52238184, 8) == 6529773);
  assert(div_int(52238192, 8) == 6529774);
  assert(div_int(52238200, 4) == 13059550);
  assert(div_int(52238288, 4) == 13059572);
  assert(div_int(52238288, 8) == 6529786);
  assert(div_int(52238292, 4) == 13059573);
  assert(div_int(52238304, 8) == 6529788);
  assert(div_int(52238312, 8) == 6529789);
  assert(div_int(52238320, 4) == 13059580);
  assert(div_int(52238320, 8) == 6529790);
  assert(div_int(52238324, 4) == 13059581);
  assert(div_int(52238328, 8) == 6529791);
  assert(div_int(52238336, 8) == 6529792);
  assert(div_int(52238344, 8) == 6529793);
  assert(div_int(52238352, 8) == 6529794);
  assert(div_int(52238360, 8) == 6529795);
  assert(div_int(52238368, 8) == 6529796);
  assert(div_int(52238376, 8) == 6529797);
  assert(div_int(52238384, 8) == 6529798);
  assert(div_int(52238392, 8) == 6529799);
  assert(div_int(52238400, 8) == 6529800);
  assert(div_int(52238408, 8) == 6529801);
  assert(div_int(52238416, 8) == 6529802);
  assert(div_int(52238424, 8) == 6529803);
  assert(div_int(52238432, 8) == 6529804);
  assert(div_int(52238440, 8) == 6529805);
  assert(div_int(52238448, 8) == 6529806);
  assert(div_int(52238456, 8) == 6529807);
  assert(div_int(52238464, 8) == 6529808);
  assert(div_int(52238472, 8) == 6529809);
  assert(div_int(52238480, 8) == 6529810);
  assert(div_int(52238488, 8) == 6529811);
  assert(div_int(52238496, 8) == 6529812);
  assert(div_int(52238504, 8) == 6529813);
  assert(div_int(52238512, 8) == 6529814);
  assert(div_int(52238520, 8) == 6529815);
  assert(div_int(52238528, 8) == 6529816);
  assert(div_int(52238544, 8) == 6529818);
  assert(div_int(52238552, 4) == 13059638);
  assert(div_int(52238552, 8) == 6529819);
  assert(div_int(52238560, 8) == 6529820);
  assert(div_int(52238568, 8) == 6529821);
  assert(div_int(52238576, 8) == 6529822);
  assert(div_int(52238584, 8) == 6529823);
  assert(div_int(52238592, 8) == 6529824);
  assert(div_int(52238600, 8) == 6529825);
  assert(div_int(52238608, 8) == 6529826);
  assert(div_int(52238616, 8) == 6529827);
  assert(div_int(52238624, 8) == 6529828);
  assert(div_int(52238632, 8) == 6529829);
  assert(div_int(52238640, 8) == 6529830);
  assert(div_int(52238648, 8) == 6529831);
  assert(div_int(52238656, 8) == 6529832);
  assert(div_int(52238664, 8) == 6529833);
  assert(div_int(52238672, 8) == 6529834);
  assert(div_int(52238680, 8) == 6529835);
  assert(div_int(52238688, 8) == 6529836);
  assert(div_int(52238696, 8) == 6529837);
  assert(div_int(52238704, 8) == 6529838);
  assert(div_int(52239232, 8) == 6529904);
  assert(div_int(52239240, 8) == 6529905);
  assert(div_int(52239248, 8) == 6529906);
  assert(div_int(52239256, 8) == 6529907);
  assert(div_int(52239264, 8) == 6529908);
  assert(div_int(52239272, 8) == 6529909);
  assert(div_int(52239280, 8) == 6529910);
  assert(div_int(52239288, 8) == 6529911);
  assert(div_int(52239296, 8) == 6529912);
  assert(div_int(52239304, 8) == 6529913);
  assert(div_int(52239312, 8) == 6529914);
  assert(div_int(52239320, 8) == 6529915);
  assert(div_int(52239328, 8) == 6529916);
  assert(div_int(52239336, 8) == 6529917);
  assert(div_int(52239344, 8) == 6529918);
  assert(div_int(52239352, 8) == 6529919);
  assert(div_int(52239360, 8) == 6529920);
  assert(div_int(52239368, 8) == 6529921);
  assert(div_int(52239376, 8) == 6529922);
  assert(div_int(52239384, 8) == 6529923);
  assert(div_int(52239392, 8) == 6529924);
  assert(div_int(52239400, 4) == 13059850);
  assert(div_int(52239404, 4) == 13059851);
  assert(div_int(52239408, 4) == 13059852);
  assert(div_int(52239412, 4) == 13059853);
  assert(div_int(52239416, 4) == 13059854);
  assert(div_int(52239420, 4) == 13059855);
  assert(div_int(52239424, 4) == 13059856);
  assert(div_int(52239428, 4) == 13059857);
  assert(div_int(52239432, 4) == 13059858);
  assert(div_int(52239436, 4) == 13059859);
  assert(div_int(52239440, 4) == 13059860);
  assert(div_int(52239444, 4) == 13059861);
  assert(div_int(52239448, 4) == 13059862);
  assert(div_int(52239452, 4) == 13059863);
  assert(div_int(52239456, 4) == 13059864);
  assert(div_int(52239460, 4) == 13059865);
  assert(div_int(52239464, 4) == 13059866);
  assert(div_int(52239468, 4) == 13059867);
  assert(div_int(52239472, 4) == 13059868);
  assert(div_int(52239476, 4) == 13059869);
  assert(div_int(52239480, 4) == 13059870);
  assert(div_int(542720, 8) == 67840);
  assert(div_int(58720273, 1) == 58720273);
  assert(div_int(58720274, 1) == 58720274);
  assert(div_int(58720275, 1) == 58720275);
  assert(div_int(58720280, 4) == 14680070);
  assert(div_int(58720315, 1) == 58720315);
  assert(div_int(58720316, 1) == 58720316);
  assert(div_int(58720317, 1) == 58720317);
  assert(div_int(58720320, 4) == 14680080);
  assert(div_int(58720332, 1) == 58720332);
  assert(div_int(58720333, 1) == 58720333);
  assert(div_int(58720334, 1) == 58720334);
  assert(div_int(58720336, 4) == 14680084);
  assert(div_int(58720960, 16) == 3670060);
  assert(div_int(58720960, 8) == 7340120);
  assert(div_int(58720968, 8) == 7340121);
  assert(div_int(58720976, 8) == 7340122);
  assert(div_int(58720984, 8) == 7340123);
  assert(div_int(58720992, 8) == 7340124);
  assert(div_int(58721000, 8) == 7340125);
  assert(div_int(58721008, 8) == 7340126);
  assert(div_int(58721016, 8) == 7340127);
  assert(div_int(58721024, 8) == 7340128);
  assert(div_int(58721040, 16) == 3670065);
  assert(div_int(58721040, 8) == 7340130);
  assert(div_int(58721048, 8) == 7340131);
  assert(div_int(58721056, 8) == 7340132);
  assert(div_int(58721064, 8) == 7340133);
  assert(div_int(58721072, 16) == 3670067);
  assert(div_int(58721072, 8) == 7340134);
  assert(div_int(58721080, 8) == 7340135);
  assert(div_int(58721088, 8) == 7340136);
  assert(div_int(58721104, 16) == 3670069);
  assert(div_int(58721104, 8) == 7340138);
  assert(div_int(58721112, 8) == 7340139);
  assert(div_int(58721120, 16) == 3670070);
  assert(div_int(58721120, 8) == 7340140);
  assert(div_int(58721128, 8) == 7340141);
  assert(div_int(58721184, 16) == 3670074);
  assert(div_int(58721184, 8) == 7340148);
  assert(div_int(58721192, 8) == 7340149);
  assert(div_int(58721200, 16) == 3670075);
  assert(div_int(58721200, 4) == 14680300);
  assert(div_int(58721200, 8) == 7340150);
  assert(div_int(58721204, 4) == 14680301);
  assert(div_int(58721208, 4) == 14680302);
  assert(div_int(58721208, 8) == 7340151);
  assert(div_int(58721212, 4) == 14680303);
  assert(div_int(58721216, 4) == 14680304);
  assert(div_int(58721216, 8) == 7340152);
  assert(div_int(58721220, 4) == 14680305);
  assert(div_int(58721224, 4) == 14680306);
  assert(div_int(58721228, 4) == 14680307);
  assert(div_int(58721232, 16) == 3670077);
  assert(div_int(58721232, 4) == 14680308);
  assert(div_int(58721232, 8) == 7340154);
  assert(div_int(58721236, 4) == 14680309);
  assert(div_int(58721240, 4) == 14680310);
  assert(div_int(58721240, 8) == 7340155);
  assert(div_int(58721244, 4) == 14680311);
  assert(div_int(58721248, 4) == 14680312);
  assert(div_int(58721248, 8) == 7340156);
  assert(div_int(58721252, 4) == 14680313);
  assert(div_int(58721256, 4) == 14680314);
  assert(div_int(58721256, 8) == 7340157);
  assert(div_int(58721260, 4) == 14680315);
  assert(div_int(58721264, 16) == 3670079);
  assert(div_int(58721264, 8) == 7340158);
  assert(div_int(58721272, 8) == 7340159);
  assert(div_int(58721280, 8) == 7340160);
  assert(div_int(58721288, 8) == 7340161);
  assert(div_int(58721296, 8) == 7340162);
  assert(div_int(58721304, 8) == 7340163);
  assert(div_int(58721312, 16) == 3670082);
  assert(div_int(58721312, 8) == 7340164);
  assert(div_int(58721320, 8) == 7340165);
  assert(div_int(58721328, 16) == 3670083);
  assert(div_int(58721328, 8) == 7340166);
  assert(div_int(58721336, 8) == 7340167);
  assert(div_int(58721344, 16) == 3670084);
  assert(div_int(58721344, 8) == 7340168);
  assert(div_int(58721352, 8) == 7340169);
  assert(div_int(58721360, 16) == 3670085);
  assert(div_int(58721360, 8) == 7340170);
  assert(div_int(58721368, 8) == 7340171);
  assert(div_int(58721376, 16) == 3670086);
  assert(div_int(58753120, 4) == 14688280);
  assert(div_int(58753124, 4) == 14688281);
  assert(div_int(58753128, 8) == 7344141);
  assert(div_int(58753136, 8) == 7344142);
  assert(div_int(58753144, 8) == 7344143);
  assert(div_int(58753152, 8) == 7344144);
  assert(div_int(58753344, 8) == 7344168);
  assert(div_int(58753352, 8) == 7344169);
  assert(div_int(58753608, 8) == 7344201);
  assert(div_int(58753616, 4) == 14688404);
  assert(div_int(58755584, 4) == 14688896);
  assert(div_int(58755588, 4) == 14688897);
  assert(div_int(58755592, 8) == 7344449);
  assert(div_int(58755600, 8) == 7344450);
  assert(div_int(58755608, 8) == 7344451);
  assert(div_int(58755616, 8) == 7344452);
  assert(div_int(58755696, 8) == 7344462);
  assert(div_int(58755704, 8) == 7344463);
  assert(div_int(58755960, 8) == 7344495);
  assert(div_int(58755968, 4) == 14688992);
  assert(div_int(58775680, 8) == 7346960);
  assert(div_int(58775688, 8) == 7346961);
  assert(div_int(58775696, 8) == 7346962);
  assert(div_int(58775704, 8) == 7346963);
  assert(div_int(58775712, 8) == 7346964);
  assert(div_int(58775720, 8) == 7346965);
  assert(div_int(58775728, 8) == 7346966);
  assert(div_int(58775736, 8) == 7346967);
  assert(div_int(58775744, 8) == 7346968);
  assert(div_int(58775752, 8) == 7346969);
  assert(div_int(58775760, 8) == 7346970);
  assert(div_int(58775768, 8) == 7346971);
  assert(div_int(58775776, 8) == 7346972);
  assert(div_int(58775784, 8) == 7346973);
  assert(div_int(58775792, 8) == 7346974);
  assert(div_int(58775800, 8) == 7346975);
  assert(div_int(58775808, 8) == 7346976);
  assert(div_int(58775816, 8) == 7346977);
  assert(div_int(58775904, 8) == 7346988);
  assert(div_int(58775912, 8) == 7346989);
  assert(div_int(58775920, 4) == 14693980);
  assert(div_int(58775920, 8) == 7346990);
  assert(div_int(58775924, 4) == 14693981);
  assert(div_int(58775928, 4) == 14693982);
  assert(div_int(58775928, 8) == 7346991);
  assert(div_int(58775932, 4) == 14693983);
  assert(div_int(58775936, 4) == 14693984);
  assert(div_int(58775936, 8) == 7346992);
  assert(div_int(58775940, 4) == 14693985);
  assert(div_int(58775944, 4) == 14693986);
  assert(div_int(58775944, 8) == 7346993);
  assert(div_int(58775948, 4) == 14693987);
  assert(div_int(58775952, 4) == 14693988);
  assert(div_int(58775952, 8) == 7346994);
  assert(div_int(58775956, 4) == 14693989);
  assert(div_int(58775960, 4) == 14693990);
  assert(div_int(58775960, 8) == 7346995);
  assert(div_int(58775964, 4) == 14693991);
  assert(div_int(58775968, 4) == 14693992);
  assert(div_int(58775968, 8) == 7346996);
  assert(div_int(58775972, 4) == 14693993);
  assert(div_int(58775976, 4) == 14693994);
  assert(div_int(58775980, 4) == 14693995);
  assert(div_int(58775984, 8) == 7346998);
  assert(div_int(58775992, 8) == 7346999);
  assert(div_int(58776000, 8) == 7347000);
  assert(div_int(58776008, 8) == 7347001);
  assert(div_int(58776016, 8) == 7347002);
  assert(div_int(58776024, 8) == 7347003);
  assert(div_int(58776032, 8) == 7347004);
  assert(div_int(58776040, 8) == 7347005);
  assert(div_int(58776048, 8) == 7347006);
  assert(div_int(58776056, 8) == 7347007);
  assert(div_int(58776064, 8) == 7347008);
  assert(div_int(58776072, 8) == 7347009);
  assert(div_int(58807824, 4) == 14701956);
  assert(div_int(58807832, 8) == 7350979);
  assert(div_int(58807844, 4) == 14701961);
  assert(div_int(58807848, 8) == 7350981);
  assert(div_int(58807856, 8) == 7350982);
  assert(div_int(58807864, 4) == 14701966);
  assert(div_int(58807868, 4) == 14701967);
  assert(div_int(58807872, 8) == 7350984);
  assert(div_int(58807880, 8) == 7350985);
  assert(div_int(58807888, 8) == 7350986);
  assert(div_int(58807896, 8) == 7350987);
  assert(div_int(58807912, 8) == 7350989);
  assert(div_int(58807920, 8) == 7350990);
  assert(div_int(58807928, 8) == 7350991);
  assert(div_int(58808184, 8) == 7351023);
  assert(div_int(58808192, 4) == 14702048);
  assert(div_int(58809168, 8) == 7351146);
  assert(div_int(58809176, 8) == 7351147);
  assert(div_int(58809432, 8) == 7351179);
  assert(div_int(58809440, 4) == 14702360);
  assert(div_int(58826112, 4) == 14706528);
  assert(div_int(58826116, 4) == 14706529);
  assert(div_int(58826120, 4) == 14706530);
  assert(div_int(58826124, 4) == 14706531);
  assert(div_int(58826128, 8) == 7353266);
  assert(div_int(58826136, 8) == 7353267);
  assert(div_int(58826144, 8) == 7353268);
  assert(div_int(58826152, 8) == 7353269);
  assert(div_int(58826168, 8) == 7353271);
  assert(div_int(58826176, 8) == 7353272);
  assert(div_int(58826184, 8) == 7353273);
  assert(div_int(58826448, 4) == 14706612);
  assert(div_int(58827392, 4) == 14706848);
  assert(div_int(58827396, 4) == 14706849);
  assert(div_int(58827400, 4) == 14706850);
  assert(div_int(58827404, 4) == 14706851);
  assert(div_int(58827408, 8) == 7353426);
  assert(div_int(58827416, 8) == 7353427);
  assert(div_int(58827424, 8) == 7353428);
  assert(div_int(58827432, 8) == 7353429);
  assert(div_int(58827448, 8) == 7353431);
  assert(div_int(58827456, 8) == 7353432);
  assert(div_int(58827464, 8) == 7353433);
  assert(div_int(58827720, 8) == 7353465);
  assert(div_int(58827728, 4) == 14706932);
  assert(div_int(58828016, 8) == 7353502);
  assert(div_int(58828672, 4) == 14707168);
  assert(div_int(58828676, 4) == 14707169);
  assert(div_int(58828680, 4) == 14707170);
  assert(div_int(58828688, 4) == 14707172);
  assert(div_int(58828696, 8) == 7353587);
  assert(div_int(58828704, 4) == 14707176);
  assert(div_int(58828708, 4) == 14707177);
  assert(div_int(58828716, 4) == 14707179);
  assert(div_int(58828720, 4) == 14707180);
  assert(div_int(58828728, 8) == 7353591);
  assert(div_int(58828736, 8) == 7353592);
  assert(div_int(58828744, 8) == 7353593);
  assert(div_int(58828760, 8) == 7353595);
  assert(div_int(58828768, 8) == 7353596);
  assert(div_int(58829024, 8) == 7353628);
  assert(div_int(58829032, 4) == 14707258);
  assert(div_int(58829320, 8) == 7353665);
  assert(div_int(58830000, 8) == 7353750);
  assert(div_int(58830008, 8) == 7353751);
  assert(div_int(58830264, 8) == 7353783);
  assert(div_int(58830272, 4) == 14707568);
  assert(div_int(58830560, 4) == 14707640);
  assert(div_int(58830564, 4) == 14707641);
  assert(div_int(58830568, 4) == 14707642);
  assert(div_int(58831184, 8) == 7353898);
  assert(div_int(58831192, 8) == 7353899);
  assert(div_int(58831200, 8) == 7353900);
  assert(div_int(58831208, 8) == 7353901);
  assert(div_int(58831216, 8) == 7353902);
  assert(div_int(58831224, 8) == 7353903);
  assert(div_int(58831232, 8) == 7353904);
  assert(div_int(58831240, 8) == 7353905);
  assert(div_int(58831248, 8) == 7353906);
  assert(div_int(58831264, 8) == 7353908);
  assert(div_int(58831272, 8) == 7353909);
  assert(div_int(58831280, 8) == 7353910);
  assert(div_int(58831288, 8) == 7353911);
  assert(div_int(58831296, 8) == 7353912);
  assert(div_int(58831304, 8) == 7353913);
  assert(div_int(58831312, 8) == 7353914);
  assert(div_int(58831320, 8) == 7353915);
  assert(div_int(58831328, 8) == 7353916);
  assert(div_int(58831336, 8) == 7353917);
  assert(div_int(58831344, 8) == 7353918);
  assert(div_int(58831352, 8) == 7353919);
  assert(div_int(58831424, 8) == 7353928);
  assert(div_int(58831432, 8) == 7353929);
  assert(div_int(58831440, 4) == 14707860);
  assert(div_int(58831440, 8) == 7353930);
  assert(div_int(58831444, 4) == 14707861);
  assert(div_int(58831448, 4) == 14707862);
  assert(div_int(58831448, 8) == 7353931);
  assert(div_int(58831452, 4) == 14707863);
  assert(div_int(58831456, 4) == 14707864);
  assert(div_int(58831456, 8) == 7353932);
  assert(div_int(58831460, 4) == 14707865);
  assert(div_int(58831464, 4) == 14707866);
  assert(div_int(58831468, 4) == 14707867);
  assert(div_int(58831472, 4) == 14707868);
  assert(div_int(58831472, 8) == 7353934);
  assert(div_int(58831476, 4) == 14707869);
  assert(div_int(58831480, 4) == 14707870);
  assert(div_int(58831480, 8) == 7353935);
  assert(div_int(58831484, 4) == 14707871);
  assert(div_int(58831488, 4) == 14707872);
  assert(div_int(58831488, 8) == 7353936);
  assert(div_int(58831492, 4) == 14707873);
  assert(div_int(58831496, 4) == 14707874);
  assert(div_int(58831496, 8) == 7353937);
  assert(div_int(58831500, 4) == 14707875);
  assert(div_int(58831504, 4) == 14707876);
  assert(div_int(58831504, 8) == 7353938);
  assert(div_int(58831512, 8) == 7353939);
  assert(div_int(58831520, 8) == 7353940);
  assert(div_int(58831528, 8) == 7353941);
  assert(div_int(58831536, 8) == 7353942);
  assert(div_int(58831544, 8) == 7353943);
  assert(div_int(58831552, 8) == 7353944);
  assert(div_int(58831560, 8) == 7353945);
  assert(div_int(58831568, 8) == 7353946);
  assert(div_int(58831576, 8) == 7353947);
  assert(div_int(58831584, 8) == 7353948);
  assert(div_int(58831592, 8) == 7353949);
  assert(div_int(58831600, 8) == 7353950);
  assert(div_int(58831608, 8) == 7353951);
  assert(div_int(64, 1) == 64);
  assert(div_int(64, 8) == 8);
  assert(div_int(69316, 4) == 17329);
  assert(div_int(69320, 4) == 17330);
  assert(div_int(69324, 4) == 17331);
  assert(div_int(69328, 4) == 17332);
  assert(div_int(69332, 4) == 17333);
  assert(div_int(69336, 4) == 17334);
  assert(div_int(69340, 4) == 17335);
  assert(div_int(69344, 4) == 17336);
  assert(div_int(69348, 4) == 17337);
  assert(div_int(69352, 4) == 17338);
  assert(div_int(69356, 4) == 17339);
  assert(div_int(69360, 4) == 17340);
  assert(div_int(69364, 4) == 17341);
  assert(div_int(69368, 4) == 17342);
  assert(div_int(69372, 4) == 17343);
  assert(div_int(69376, 4) == 17344);
  assert(div_int(69380, 4) == 17345);
  assert(div_int(69384, 4) == 17346);
  assert(div_int(69388, 4) == 17347);
  assert(div_int(69392, 4) == 17348);
  assert(div_int(69396, 4) == 17349);
  assert(div_int(69400, 4) == 17350);
  assert(div_int(69404, 4) == 17351);
  assert(div_int(69408, 4) == 17352);
  assert(div_int(69412, 4) == 17353);
  assert(div_int(69416, 4) == 17354);
  assert(div_int(69420, 4) == 17355);
  assert(div_int(69424, 4) == 17356);
  assert(div_int(69428, 4) == 17357);
  assert(div_int(69432, 4) == 17358);
  assert(div_int(69436, 4) == 17359);
  assert(div_int(69440, 4) == 17360);
  assert(div_int(69444, 4) == 17361);
  assert(div_int(69448, 4) == 17362);
  assert(div_int(69452, 4) == 17363);
  assert(div_int(69456, 4) == 17364);
  assert(div_int(69460, 4) == 17365);
  assert(div_int(69464, 4) == 17366);
  assert(div_int(69468, 4) == 17367);
  assert(div_int(69472, 4) == 17368);
  assert(div_int(69476, 4) == 17369);
  assert(div_int(69480, 4) == 17370);
  assert(div_int(69484, 4) == 17371);
  assert(div_int(69968, 8) == 8746);
  assert(div_int(75120, 4) == 18780);
  assert(div_int(75124, 4) == 18781);
  assert(div_int(75128, 4) == 18782);
  assert(div_int(75132, 4) == 18783);
  assert(div_int(75136, 4) == 18784);
  assert(div_int(75140, 4) == 18785);
  assert(div_int(75144, 4) == 18786);
  assert(div_int(75148, 4) == 18787);
  assert(div_int(75152, 4) == 18788);
  assert(div_int(75156, 4) == 18789);
  assert(div_int(75160, 4) == 18790);
  assert(div_int(75164, 4) == 18791);
  assert(div_int(75168, 4) == 18792);
  assert(div_int(75172, 4) == 18793);
  assert(div_int(75176, 4) == 18794);
  assert(div_int(75180, 4) == 18795);
  assert(div_int(75184, 4) == 18796);
  assert(div_int(75188, 4) == 18797);
  assert(div_int(75192, 4) == 18798);
  assert(div_int(75196, 4) == 18799);
  assert(div_int(75200, 4) == 18800);
  assert(div_int(75204, 4) == 18801);
  assert(div_int(75208, 4) == 18802);
  assert(div_int(75212, 4) == 18803);
  assert(div_int(75216, 4) == 18804);
  assert(div_int(75220, 4) == 18805);
  assert(div_int(75224, 4) == 18806);
  assert(div_int(75228, 4) == 18807);
  assert(div_int(75232, 4) == 18808);
  assert(div_int(75236, 4) == 18809);
  assert(div_int(75240, 4) == 18810);
  assert(div_int(75244, 4) == 18811);
  assert(div_int(75248, 4) == 18812);
  assert(div_int(75252, 4) == 18813);
  assert(div_int(75256, 4) == 18814);
  assert(div_int(75260, 4) == 18815);
  assert(div_int(75264, 4) == 18816);
  assert(div_int(75268, 4) == 18817);
  assert(div_int(75272, 4) == 18818);
  assert(div_int(75276, 4) == 18819);
  assert(div_int(75280, 4) == 18820);
  assert(div_int(75296, 8) == 9412);
  assert(div_int(75872, 8) == 9484);
  assert(div_int(8, 8) == 1);
  assert(div_int(800, 10) == 80);
  assert(div_int(82944, 4) == 20736);
  assert(div_int(84660, 4) == 21165);
  assert(div_int(84664, 4) == 21166);
  assert(div_int(84668, 4) == 21167);
  assert(div_int(84672, 4) == 21168);
  assert(div_int(84676, 4) == 21169);
  assert(div_int(84680, 4) == 21170);
  assert(div_int(84692, 4) == 21173);
  assert(div_int(84696, 4) == 21174);
  assert(div_int(84700, 4) == 21175);
  assert(div_int(84704, 4) == 21176);
  assert(div_int(84708, 4) == 21177);
  assert(div_int(84712, 4) == 21178);
  assert(div_int(84716, 4) == 21179);
  assert(div_int(84720, 4) == 21180);
  assert(div_int(84724, 4) == 21181);
  assert(div_int(84728, 4) == 21182);
  assert(div_int(84732, 4) == 21183);
  assert(div_int(84736, 4) == 21184);
  assert(div_int(84740, 4) == 21185);
  assert(div_int(84872, 4) == 21218);
  assert(div_int(84876, 4) == 21219);
  assert(div_int(84880, 4) == 21220);
  assert(div_int(84884, 4) == 21221);
  assert(div_int(84888, 4) == 21222);
  assert(div_int(84892, 4) == 21223);
  assert(div_int(84896, 4) == 21224);
  assert(div_int(84900, 4) == 21225);
  assert(div_int(84904, 4) == 21226);
  assert(div_int(84908, 4) == 21227);
  assert(div_int(84912, 4) == 21228);
  assert(div_int(84916, 4) == 21229);
  assert(div_int(84920, 4) == 21230);
  assert(div_int(84924, 4) == 21231);
  assert(div_int(85348, 4) == 21337);
  assert(div_int(85352, 4) == 21338);
  assert(div_int(85356, 4) == 21339);
  assert(div_int(85360, 4) == 21340);
  assert(div_int(85364, 4) == 21341);
  assert(div_int(85368, 4) == 21342);
  assert(div_int(85372, 4) == 21343);
  assert(div_int(85376, 4) == 21344);
  assert(div_int(85380, 4) == 21345);
  assert(div_int(85384, 4) == 21346);
  assert(div_int(85388, 4) == 21347);
  assert(div_int(85392, 4) == 21348);
  assert(div_int(85396, 4) == 21349);
  assert(div_int(85400, 4) == 21350);
  assert(div_int(85404, 4) == 21351);
  assert(div_int(85408, 4) == 21352);
  assert(div_int(85412, 4) == 21353);
  assert(div_int(85416, 4) == 21354);
  assert(div_int(85420, 4) == 21355);
  assert(div_int(85424, 4) == 21356);
  assert(div_int(85428, 4) == 21357);
  assert(div_int(85432, 4) == 21358);
  assert(div_int(85436, 4) == 21359);
  assert(div_int(85440, 4) == 21360);
  assert(div_int(85444, 4) == 21361);
  assert(div_int(85448, 4) == 21362);
  assert(div_int(85452, 4) == 21363);
  assert(div_int(85456, 4) == 21364);
  assert(div_int(85460, 4) == 21365);
  assert(div_int(85464, 4) == 21366);
  assert(div_int(85468, 4) == 21367);
  assert(div_int(85472, 4) == 21368);
  assert(div_int(85476, 4) == 21369);
  assert(div_int(85480, 4) == 21370);
  assert(div_int(85484, 4) == 21371);
  assert(div_int(85488, 4) == 21372);
  assert(div_int(85492, 4) == 21373);
  assert(div_int(85496, 4) == 21374);
  assert(div_int(85500, 4) == 21375);
  assert(div_int(85504, 4) == 21376);
  assert(div_int(85508, 4) == 21377);
  assert(div_int(85512, 4) == 21378);
  assert(div_int(90688, 4) == 22672);
  assert(div_int(90692, 4) == 22673);
  assert(div_int(90896, 4) == 22724);
  assert(div_int(90900, 4) == 22725);
  assert(div_int(90904, 4) == 22726);
  assert(div_int(90908, 4) == 22727);
  assert(div_int(90912, 4) == 22728);
  assert(div_int(90916, 4) == 22729);
  assert(div_int(90920, 4) == 22730);
  assert(div_int(90924, 4) == 22731);
  assert(div_int(90928, 4) == 22732);
  assert(div_int(90932, 4) == 22733);
  assert(div_int(90984, 4) == 22746);
  assert(div_int(90988, 4) == 22747);
  assert(div_int(91012, 4) == 22753);
  assert(div_int(91016, 8) == 11377);
  assert(div_int(91072, 4) == 22768);
  assert(div_int(91076, 4) == 22769);
  assert(div_int(91088, 4) == 22772);
  assert(div_int(91092, 4) == 22773);
  assert(div_int(91104, 4) == 22776);
  assert(div_int(91108, 4) == 22777);
  assert(div_int(91120, 4) == 22780);
  assert(div_int(91124, 4) == 22781);
  assert(div_int(91128, 4) == 22782);
  assert(div_int(91132, 4) == 22783);
  assert(div_int(91136, 4) == 22784);
  assert(div_int(91140, 4) == 22785);
  assert(div_int(91144, 4) == 22786);
  assert(div_int(91148, 4) == 22787);
  assert(div_int(91168, 4) == 22792);
  assert(div_int(91172, 4) == 22793);
  assert(div_int(91176, 4) == 22794);
  assert(div_int(91180, 4) == 22795);
  assert(div_int(91212, 4) == 22803);
  assert(div_int(91216, 4) == 22804);
  assert(div_int(91228, 4) == 22807);
  assert(div_int(91232, 4) == 22808);
  assert(div_int(91236, 4) == 22809);
  assert(div_int(91252, 4) == 22813);
  assert(div_int(91256, 4) == 22814);
  assert(div_int(91260, 4) == 22815);
  assert(div_int(91264, 4) == 22816);
  assert(div_int(91268, 4) == 22817);
  assert(div_int(91272, 4) == 22818);
  assert(div_int(91276, 4) == 22819);
  assert(div_int(91280, 4) == 22820);
  assert(div_int(91284, 4) == 22821);
  assert(div_int(91288, 4) == 22822);
  assert(div_int(91292, 4) == 22823);
  assert(div_int(91296, 4) == 22824);
  assert(div_int(91300, 4) == 22825);
  assert(div_int(91304, 4) == 22826);
  assert(div_int(91308, 4) == 22827);
  assert(div_int(91312, 4) == 22828);
  assert(div_int(91316, 4) == 22829);
  assert(div_int(91320, 4) == 22830);
  assert(div_int(91348, 4) == 22837);
  assert(div_int(91352, 4) == 22838);
  assert(div_int(91356, 4) == 22839);
  assert(div_int(91360, 4) == 22840);
  assert(div_int(91408, 4) == 22852);
  assert(div_int(91412, 4) == 22853);
  assert(div_int(91416, 4) == 22854);
  assert(div_int(91816, 4) == 22954);
  assert(div_int(91820, 4) == 22955);
  assert(div_int(91824, 4) == 22956);
  assert(div_int(91828, 4) == 22957);
}