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(0, 8) == 0);
  assert(div_int(1000, 12) == 83);
  assert(div_int(102850560, 1) == 102850560);
  assert(div_int(102850561, 1) == 102850561);
  assert(div_int(102850562, 1) == 102850562);
  assert(div_int(102850563, 1) == 102850563);
  assert(div_int(102850663, 1) == 102850663);
  assert(div_int(102850666, 1) == 102850666);
  assert(div_int(102850667, 1) == 102850667);
  assert(div_int(102850668, 1) == 102850668);
  assert(div_int(1052672, 4) == 263168);
  assert(div_int(1052676, 4) == 263169);
  assert(div_int(1052680, 4) == 263170);
  assert(div_int(1052684, 4) == 263171);
  assert(div_int(1052688, 4) == 263172);
  assert(div_int(1052692, 4) == 263173);
  assert(div_int(1052696, 4) == 263174);
  assert(div_int(1052700, 4) == 263175);
  assert(div_int(1065388, 4) == 266347);
  assert(div_int(1065392, 4) == 266348);
  assert(div_int(1065396, 4) == 266349);
  assert(div_int(1065400, 4) == 266350);
  assert(div_int(1065404, 4) == 266351);
  assert(div_int(1065408, 4) == 266352);
  assert(div_int(1065472, 4) == 266368);
  assert(div_int(1065476, 4) == 266369);
  assert(div_int(1065480, 4) == 266370);
  assert(div_int(1065484, 4) == 266371);
  assert(div_int(1065488, 4) == 266372);
  assert(div_int(1065492, 4) == 266373);
  assert(div_int(1065496, 4) == 266374);
  assert(div_int(1065500, 4) == 266375);
  assert(div_int(1065504, 4) == 266376);
  assert(div_int(1065508, 4) == 266377);
  assert(div_int(1065512, 4) == 266378);
  assert(div_int(1065552, 8) == 133194);
  assert(div_int(1065560, 8) == 133195);
  assert(div_int(1065568, 8) == 133196);
  assert(div_int(1065576, 8) == 133197);
  assert(div_int(1065584, 8) == 133198);
  assert(div_int(1065592, 4) == 266398);
  assert(div_int(1065596, 4) == 266399);
  assert(div_int(1065600, 4) == 266400);
  assert(div_int(1065604, 4) == 266401);
  assert(div_int(1065656, 4) == 266414);
  assert(div_int(1065660, 4) == 266415);
  assert(div_int(1065684, 4) == 266421);
  assert(div_int(1065696, 8) == 133212);
  assert(div_int(1065728, 8) == 133216);
  assert(div_int(1065736, 8) == 133217);
  assert(div_int(1065744, 8) == 133218);
  assert(div_int(1065760, 8) == 133220);
  assert(div_int(1065768, 8) == 133221);
  assert(div_int(1065776, 8) == 133222);
  assert(div_int(1065784, 8) == 133223);
  assert(div_int(1065792, 8) == 133224);
  assert(div_int(1065824, 4) == 266456);
  assert(div_int(1066000, 8) == 133250);
  assert(div_int(1066008, 8) == 133251);
  assert(div_int(1066016, 8) == 133252);
  assert(div_int(1066024, 8) == 133253);
  assert(div_int(1066400, 16) == 66650);
  assert(div_int(1066400, 4) == 266600);
  assert(div_int(1066400, 8) == 133300);
  assert(div_int(1066404, 4) == 266601);
  assert(div_int(1066416, 8) == 133302);
  assert(div_int(1066424, 8) == 133303);
  assert(div_int(1066432, 16) == 66652);
  assert(div_int(1066432, 4) == 266608);
  assert(div_int(1066432, 8) == 133304);
  assert(div_int(1066436, 4) == 266609);
  assert(div_int(1066440, 8) == 133305);
  assert(div_int(1066448, 8) == 133306);
  assert(div_int(1066456, 8) == 133307);
  assert(div_int(1066464, 8) == 133308);
  assert(div_int(1066472, 8) == 133309);
  assert(div_int(1066480, 8) == 133310);
  assert(div_int(1066488, 8) == 133311);
  assert(div_int(1066496, 8) == 133312);
  assert(div_int(1066504, 8) == 133313);
  assert(div_int(1066512, 8) == 133314);
  assert(div_int(1066520, 8) == 133315);
  assert(div_int(1066528, 8) == 133316);
  assert(div_int(1066536, 8) == 133317);
  assert(div_int(1066544, 8) == 133318);
  assert(div_int(1066552, 8) == 133319);
  assert(div_int(1066560, 8) == 133320);
  assert(div_int(1066568, 8) == 133321);
  assert(div_int(1066576, 8) == 133322);
  assert(div_int(1066584, 8) == 133323);
  assert(div_int(1066592, 8) == 133324);
  assert(div_int(1066600, 8) == 133325);
  assert(div_int(1066608, 16) == 66663);
  assert(div_int(1066608, 8) == 133326);
  assert(div_int(1070960, 4) == 267740);
  assert(div_int(1070964, 4) == 267741);
  assert(div_int(1070968, 4) == 267742);
  assert(div_int(1070976, 8) == 133872);
  assert(div_int(1071016, 4) == 267754);
  assert(div_int(1071024, 8) == 133878);
  assert(div_int(1071032, 8) == 133879);
  assert(div_int(1071040, 8) == 133880);
  assert(div_int(1071048, 8) == 133881);
  assert(div_int(1071056, 8) == 133882);
  assert(div_int(1071064, 8) == 133883);
  assert(div_int(1071072, 8) == 133884);
  assert(div_int(1071080, 8) == 133885);
  assert(div_int(1071088, 8) == 133886);
  assert(div_int(1071096, 8) == 133887);
  assert(div_int(1071104, 8) == 133888);
  assert(div_int(1071112, 8) == 133889);
  assert(div_int(1071120, 8) == 133890);
  assert(div_int(1071128, 8) == 133891);
  assert(div_int(1071136, 8) == 133892);
  assert(div_int(1071144, 8) == 133893);
  assert(div_int(1071152, 8) == 133894);
  assert(div_int(1071160, 8) == 133895);
  assert(div_int(1071168, 8) == 133896);
  assert(div_int(1071176, 8) == 133897);
  assert(div_int(1071184, 8) == 133898);
  assert(div_int(1071192, 4) == 267798);
  assert(div_int(1071196, 4) == 267799);
  assert(div_int(1071200, 4) == 267800);
  assert(div_int(1071204, 4) == 267801);
  assert(div_int(1071208, 4) == 267802);
  assert(div_int(1071212, 4) == 267803);
  assert(div_int(1071216, 4) == 267804);
  assert(div_int(1071220, 4) == 267805);
  assert(div_int(1071224, 4) == 267806);
  assert(div_int(1071228, 4) == 267807);
  assert(div_int(1071232, 4) == 267808);
  assert(div_int(1071236, 4) == 267809);
  assert(div_int(1071240, 4) == 267810);
  assert(div_int(1071244, 4) == 267811);
  assert(div_int(1071248, 4) == 267812);
  assert(div_int(1071252, 4) == 267813);
  assert(div_int(1071256, 4) == 267814);
  assert(div_int(1071260, 4) == 267815);
  assert(div_int(1071264, 4) == 267816);
  assert(div_int(1071268, 4) == 267817);
  assert(div_int(1071272, 4) == 267818);
  assert(div_int(107920, 4) == 26980);
  assert(div_int(107924, 4) == 26981);
  assert(div_int(107928, 4) == 26982);
  assert(div_int(107932, 4) == 26983);
  assert(div_int(107936, 4) == 26984);
  assert(div_int(107940, 4) == 26985);
  assert(div_int(107944, 4) == 26986);
  assert(div_int(107948, 4) == 26987);
  assert(div_int(107952, 4) == 26988);
  assert(div_int(107956, 4) == 26989);
  assert(div_int(107960, 4) == 26990);
  assert(div_int(107964, 4) == 26991);
  assert(div_int(107988, 4) == 26997);
  assert(div_int(107992, 4) == 26998);
  assert(div_int(108020, 4) == 27005);
  assert(div_int(108024, 4) == 27006);
  assert(div_int(124488, 4) == 31122);
  assert(div_int(124492, 4) == 31123);
  assert(div_int(124496, 8) == 15562);
  assert(div_int(124504, 4) == 31126);
  assert(div_int(124508, 4) == 31127);
  assert(div_int(124512, 4) == 31128);
  assert(div_int(124516, 4) == 31129);
  assert(div_int(124520, 4) == 31130);
  assert(div_int(124524, 4) == 31131);
  assert(div_int(124528, 4) == 31132);
  assert(div_int(124532, 4) == 31133);
  assert(div_int(124536, 4) == 31134);
  assert(div_int(124540, 4) == 31135);
  assert(div_int(124544, 4) == 31136);
  assert(div_int(124548, 4) == 31137);
  assert(div_int(124552, 4) == 31138);
  assert(div_int(124556, 4) == 31139);
  assert(div_int(124560, 4) == 31140);
  assert(div_int(124564, 4) == 31141);
  assert(div_int(124568, 4) == 31142);
  assert(div_int(124572, 4) == 31143);
  assert(div_int(124576, 4) == 31144);
  assert(div_int(124580, 4) == 31145);
  assert(div_int(124584, 4) == 31146);
  assert(div_int(124584, 8) == 15573);
  assert(div_int(124588, 4) == 31147);
  assert(div_int(124592, 4) == 31148);
  assert(div_int(124596, 4) == 31149);
  assert(div_int(124600, 4) == 31150);
  assert(div_int(124604, 4) == 31151);
  assert(div_int(124608, 4) == 31152);
  assert(div_int(124612, 4) == 31153);
  assert(div_int(124616, 4) == 31154);
  assert(div_int(124620, 4) == 31155);
  assert(div_int(124624, 4) == 31156);
  assert(div_int(124628, 4) == 31157);
  assert(div_int(16777516, 4) == 4194379);
  assert(div_int(16777520, 4) == 4194380);
  assert(div_int(16777524, 4) == 4194381);
  assert(div_int(16777528, 4) == 4194382);
  assert(div_int(16777532, 4) == 4194383);
  assert(div_int(16777536, 4) == 4194384);
  assert(div_int(16777540, 4) == 4194385);
  assert(div_int(16777544, 4) == 4194386);
  assert(div_int(16777548, 4) == 4194387);
  assert(div_int(16777552, 4) == 4194388);
  assert(div_int(16777556, 4) == 4194389);
  assert(div_int(16777560, 4) == 4194390);
  assert(div_int(16777564, 4) == 4194391);
  assert(div_int(16777568, 4) == 4194392);
  assert(div_int(16777572, 4) == 4194393);
  assert(div_int(16777576, 4) == 4194394);
  assert(div_int(16777580, 4) == 4194395);
  assert(div_int(16777584, 4) == 4194396);
  assert(div_int(16777588, 4) == 4194397);
  assert(div_int(16777592, 4) == 4194398);
  assert(div_int(16777596, 4) == 4194399);
  assert(div_int(16777600, 4) == 4194400);
  assert(div_int(16777604, 4) == 4194401);
  assert(div_int(16777608, 4) == 4194402);
  assert(div_int(16777612, 4) == 4194403);
  assert(div_int(16777616, 4) == 4194404);
  assert(div_int(16777620, 4) == 4194405);
  assert(div_int(16777624, 4) == 4194406);
  assert(div_int(16777628, 4) == 4194407);
  assert(div_int(16777632, 4) == 4194408);
  assert(div_int(16777636, 4) == 4194409);
  assert(div_int(16777640, 4) == 4194410);
  assert(div_int(16777644, 4) == 4194411);
  assert(div_int(16777648, 4) == 4194412);
  assert(div_int(16777652, 4) == 4194413);
  assert(div_int(16777656, 4) == 4194414);
  assert(div_int(16777660, 4) == 4194415);
  assert(div_int(16777664, 4) == 4194416);
  assert(div_int(16777668, 4) == 4194417);
  assert(div_int(16777672, 4) == 4194418);
  assert(div_int(16777676, 4) == 4194419);
  assert(div_int(16777680, 4) == 4194420);
  assert(div_int(16777684, 4) == 4194421);
  assert(div_int(16777688, 4) == 4194422);
  assert(div_int(16777692, 4) == 4194423);
  assert(div_int(16777696, 4) == 4194424);
  assert(div_int(16777700, 4) == 4194425);
  assert(div_int(16777704, 4) == 4194426);
  assert(div_int(16777708, 4) == 4194427);
  assert(div_int(16777712, 4) == 4194428);
  assert(div_int(16777716, 4) == 4194429);
  assert(div_int(16777720, 4) == 4194430);
  assert(div_int(16777724, 4) == 4194431);
  assert(div_int(16777728, 4) == 4194432);
  assert(div_int(16777732, 4) == 4194433);
  assert(div_int(16777736, 4) == 4194434);
  assert(div_int(16777740, 4) == 4194435);
  assert(div_int(16777744, 4) == 4194436);
  assert(div_int(16777748, 4) == 4194437);
  assert(div_int(16777752, 4) == 4194438);
  assert(div_int(16777756, 4) == 4194439);
  assert(div_int(16777760, 4) == 4194440);
  assert(div_int(16777764, 4) == 4194441);
  assert(div_int(16777768, 4) == 4194442);
  assert(div_int(16777772, 4) == 4194443);
  assert(div_int(16777776, 4) == 4194444);
  assert(div_int(16777780, 4) == 4194445);
  assert(div_int(16777784, 4) == 4194446);
  assert(div_int(16777788, 4) == 4194447);
  assert(div_int(16777792, 4) == 4194448);
  assert(div_int(16777796, 4) == 4194449);
  assert(div_int(16777800, 4) == 4194450);
  assert(div_int(16777804, 4) == 4194451);
  assert(div_int(16777808, 4) == 4194452);
  assert(div_int(16777812, 4) == 4194453);
  assert(div_int(16777816, 4) == 4194454);
  assert(div_int(16777820, 4) == 4194455);
  assert(div_int(16778324, 4) == 4194581);
  assert(div_int(16778328, 4) == 4194582);
  assert(div_int(16778332, 4) == 4194583);
  assert(div_int(16778336, 4) == 4194584);
  assert(div_int(16778340, 4) == 4194585);
  assert(div_int(16778344, 4) == 4194586);
  assert(div_int(16778348, 4) == 4194587);
  assert(div_int(16778352, 4) == 4194588);
  assert(div_int(16778356, 4) == 4194589);
  assert(div_int(16778360, 4) == 4194590);
  assert(div_int(16778364, 4) == 4194591);
  assert(div_int(16778368, 4) == 4194592);
  assert(div_int(16778372, 4) == 4194593);
  assert(div_int(16778376, 4) == 4194594);
  assert(div_int(16778380, 4) == 4194595);
  assert(div_int(16778384, 4) == 4194596);
  assert(div_int(16778388, 4) == 4194597);
  assert(div_int(16778392, 4) == 4194598);
  assert(div_int(16778396, 4) == 4194599);
  assert(div_int(16778400, 4) == 4194600);
  assert(div_int(16778404, 4) == 4194601);
  assert(div_int(16778408, 4) == 4194602);
  assert(div_int(16778412, 4) == 4194603);
  assert(div_int(16778416, 4) == 4194604);
  assert(div_int(16778420, 4) == 4194605);
  assert(div_int(16778424, 4) == 4194606);
  assert(div_int(16778428, 4) == 4194607);
  assert(div_int(16778432, 4) == 4194608);
  assert(div_int(16778436, 4) == 4194609);
  assert(div_int(16778440, 4) == 4194610);
  assert(div_int(16778444, 4) == 4194611);
  assert(div_int(16778448, 4) == 4194612);
  assert(div_int(16778456, 8) == 2097307);
  assert(div_int(16778464, 4) == 4194616);
  assert(div_int(16778468, 4) == 4194617);
  assert(div_int(16778472, 4) == 4194618);
  assert(div_int(16778476, 4) == 4194619);
  assert(div_int(16778480, 4) == 4194620);
  assert(div_int(16778484, 4) == 4194621);
  assert(div_int(16778488, 4) == 4194622);
  assert(div_int(16778492, 4) == 4194623);
  assert(div_int(16778496, 4) == 4194624);
  assert(div_int(16778500, 4) == 4194625);
  assert(div_int(16778504, 4) == 4194626);
  assert(div_int(16778508, 4) == 4194627);
  assert(div_int(16778512, 4) == 4194628);
  assert(div_int(16778516, 4) == 4194629);
  assert(div_int(16778520, 4) == 4194630);
  assert(div_int(16778524, 4) == 4194631);
  assert(div_int(16778528, 4) == 4194632);
  assert(div_int(16778532, 4) == 4194633);
  assert(div_int(16778536, 4) == 4194634);
  assert(div_int(16778540, 4) == 4194635);
  assert(div_int(16778544, 4) == 4194636);
  assert(div_int(16778548, 4) == 4194637);
  assert(div_int(16778552, 4) == 4194638);
  assert(div_int(16778556, 4) == 4194639);
  assert(div_int(16778560, 4) == 4194640);
  assert(div_int(16778564, 4) == 4194641);
  assert(div_int(16778568, 4) == 4194642);
  assert(div_int(16779268, 4) == 4194817);
  assert(div_int(16779272, 4) == 4194818);
  assert(div_int(16779276, 4) == 4194819);
  assert(div_int(16779280, 4) == 4194820);
  assert(div_int(16779284, 4) == 4194821);
  assert(div_int(16779288, 4) == 4194822);
  assert(div_int(169869312, 4) == 42467328);
  assert(div_int(169869316, 4) == 42467329);
  assert(div_int(169869320, 8) == 21233665);
  assert(div_int(169869328, 4) == 42467332);
  assert(div_int(169869332, 4) == 42467333);
  assert(div_int(169869336, 8) == 21233667);
  assert(div_int(169869344, 4) == 42467336);
  assert(div_int(169869348, 4) == 42467337);
  assert(div_int(169869352, 8) == 21233669);
  assert(div_int(169869360, 4) == 42467340);
  assert(div_int(169869364, 4) == 42467341);
  assert(div_int(169869368, 8) == 21233671);
  assert(div_int(169869376, 4) == 42467344);
  assert(div_int(169869380, 4) == 42467345);
  assert(div_int(169869384, 8) == 21233673);
  assert(div_int(169869392, 4) == 42467348);
  assert(div_int(169869396, 4) == 42467349);
  assert(div_int(169869400, 4) == 42467350);
  assert(div_int(169869404, 4) == 42467351);
  assert(div_int(169869408, 4) == 42467352);
  assert(div_int(169869412, 4) == 42467353);
  assert(div_int(169869416, 4) == 42467354);
  assert(div_int(169869420, 4) == 42467355);
  assert(div_int(169869424, 4) == 42467356);
  assert(div_int(169869428, 4) == 42467357);
  assert(div_int(169869432, 4) == 42467358);
  assert(div_int(169869436, 4) == 42467359);
  assert(div_int(169869440, 4) == 42467360);
  assert(div_int(169869444, 4) == 42467361);
  assert(div_int(169869448, 4) == 42467362);
  assert(div_int(169869452, 4) == 42467363);
  assert(div_int(169869456, 4) == 42467364);
  assert(div_int(169869460, 4) == 42467365);
  assert(div_int(169869464, 4) == 42467366);
  assert(div_int(169869468, 4) == 42467367);
  assert(div_int(169869472, 4) == 42467368);
  assert(div_int(169869476, 4) == 42467369);
  assert(div_int(169869480, 4) == 42467370);
  assert(div_int(169869484, 4) == 42467371);
  assert(div_int(173015148, 4) == 43253787);
  assert(div_int(173015152, 4) == 43253788);
  assert(div_int(173015156, 4) == 43253789);
  assert(div_int(173800, 1798) == 96);
  assert(div_int(180224, 8) == 22528);
  assert(div_int(18874460, 4) == 4718615);
  assert(div_int(18874464, 4) == 4718616);
  assert(div_int(18874468, 4) == 4718617);
  assert(div_int(196608, 8) == 24576);
  assert(div_int(19923816, 4) == 4980954);
  assert(div_int(19923820, 4) == 4980955);
  assert(div_int(19923824, 4) == 4980956);
  assert(div_int(19924152, 4) == 4981038);
  assert(div_int(19924156, 4) == 4981039);
  assert(div_int(19924160, 4) == 4981040);
  assert(div_int(19924488, 4) == 4981122);
  assert(div_int(19924492, 4) == 4981123);
  assert(div_int(19924496, 4) == 4981124);
  assert(div_int(19925264, 4) == 4981316);
  assert(div_int(19925268, 4) == 4981317);
  assert(div_int(19925272, 4) == 4981318);
  assert(div_int(20940628, 4) == 5235157);
  assert(div_int(20940632, 4) == 5235158);
  assert(div_int(20940636, 4) == 5235159);
  assert(div_int(20940964, 4) == 5235241);
  assert(div_int(20940968, 4) == 5235242);
  assert(div_int(20940972, 4) == 5235243);
  assert(div_int(20971520, 4) == 5242880);
  assert(div_int(20971524, 1) == 20971524);
  assert(div_int(20971525, 1) == 20971525);
  assert(div_int(20971526, 1) == 20971526);
  assert(div_int(20971527, 1) == 20971527);
  assert(div_int(20971528, 1) == 20971528);
  assert(div_int(20971529, 1) == 20971529);
  assert(div_int(20971530, 1) == 20971530);
  assert(div_int(20971531, 1) == 20971531);
  assert(div_int(20971532, 1) == 20971532);
  assert(div_int(20971533, 1) == 20971533);
  assert(div_int(20971534, 1) == 20971534);
  assert(div_int(20971535, 1) == 20971535);
  assert(div_int(20971536, 1) == 20971536);
  assert(div_int(20971537, 1) == 20971537);
  assert(div_int(20971540, 4) == 5242885);
  assert(div_int(20971544, 4) == 5242886);
  assert(div_int(20971548, 4) == 5242887);
  assert(div_int(20971552, 4) == 5242888);
  assert(div_int(20971556, 4) == 5242889);
  assert(div_int(20971560, 4) == 5242890);
  assert(div_int(20971564, 4) == 5242891);
  assert(div_int(20971568, 4) == 5242892);
  assert(div_int(20971576, 4) == 5242894);
  assert(div_int(20971580, 4) == 5242895);
  assert(div_int(20971588, 4) == 5242897);
  assert(div_int(20971592, 4) == 5242898);
  assert(div_int(20971596, 4) == 5242899);
  assert(div_int(20971600, 4) == 5242900);
  assert(div_int(20971604, 4) == 5242901);
  assert(div_int(20971608, 4) == 5242902);
  assert(div_int(20971612, 4) == 5242903);
  assert(div_int(20971616, 4) == 5242904);
  assert(div_int(20971620, 4) == 5242905);
  assert(div_int(20971624, 4) == 5242906);
  assert(div_int(20971632, 4) == 5242908);
  assert(div_int(20971636, 4) == 5242909);
  assert(div_int(20971648, 4) == 5242912);
  assert(div_int(20971652, 4) == 5242913);
  assert(div_int(20971656, 4) == 5242914);
  assert(div_int(20971660, 4) == 5242915);
  assert(div_int(20971664, 4) == 5242916);
  assert(div_int(20971668, 4) == 5242917);
  assert(div_int(20971672, 4) == 5242918);
  assert(div_int(20971676, 4) == 5242919);
  assert(div_int(20971680, 4) == 5242920);
  assert(div_int(20971684, 4) == 5242921);
  assert(div_int(20971688, 4) == 5242922);
  assert(div_int(20971692, 4) == 5242923);
  assert(div_int(20971696, 4) == 5242924);
  assert(div_int(20971700, 4) == 5242925);
  assert(div_int(20971704, 4) == 5242926);
  assert(div_int(20971708, 4) == 5242927);
  assert(div_int(20971712, 4) == 5242928);
  assert(div_int(20971716, 4) == 5242929);
  assert(div_int(20971720, 4) == 5242930);
  assert(div_int(20971724, 4) == 5242931);
  assert(div_int(20971728, 4) == 5242932);
  assert(div_int(20971732, 4) == 5242933);
  assert(div_int(20971736, 4) == 5242934);
  assert(div_int(20971740, 4) == 5242935);
  assert(div_int(20971744, 4) == 5242936);
  assert(div_int(20971748, 4) == 5242937);
  assert(div_int(20971752, 4) == 5242938);
  assert(div_int(20971756, 4) == 5242939);
  assert(div_int(20971760, 4) == 5242940);
  assert(div_int(20971764, 4) == 5242941);
  assert(div_int(20971768, 4) == 5242942);
  assert(div_int(20971776, 4) == 5242944);
  assert(div_int(20971780, 4) == 5242945);
  assert(div_int(20971784, 4) == 5242946);
  assert(div_int(20971788, 4) == 5242947);
  assert(div_int(20971792, 4) == 5242948);
  assert(div_int(20971796, 4) == 5242949);
  assert(div_int(20971800, 4) == 5242950);
  assert(div_int(20971804, 4) == 5242951);
  assert(div_int(20971808, 4) == 5242952);
  assert(div_int(20971812, 4) == 5242953);
  assert(div_int(20971816, 4) == 5242954);
  assert(div_int(20971820, 4) == 5242955);
  assert(div_int(20971824, 4) == 5242956);
  assert(div_int(20971828, 4) == 5242957);
  assert(div_int(20971832, 4) == 5242958);
  assert(div_int(20971836, 4) == 5242959);
  assert(div_int(20971840, 4) == 5242960);
  assert(div_int(20971848, 4) == 5242962);
  assert(div_int(20971852, 4) == 5242963);
  assert(div_int(20971860, 4) == 5242965);
  assert(div_int(20971864, 4) == 5242966);
  assert(div_int(20971868, 4) == 5242967);
  assert(div_int(20971872, 4) == 5242968);
  assert(div_int(20971876, 4) == 5242969);
  assert(div_int(20971880, 4) == 5242970);
  assert(div_int(20971884, 4) == 5242971);
  assert(div_int(20971888, 4) == 5242972);
  assert(div_int(20971892, 4) == 5242973);
  assert(div_int(20971896, 4) == 5242974);
  assert(div_int(20971900, 4) == 5242975);
  assert(div_int(20971904, 4) == 5242976);
  assert(div_int(20971908, 4) == 5242977);
  assert(div_int(20971912, 4) == 5242978);
  assert(div_int(20971920, 4) == 5242980);
  assert(div_int(20971924, 4) == 5242981);
  assert(div_int(20971928, 4) == 5242982);
  assert(div_int(20971932, 4) == 5242983);
  assert(div_int(20971936, 4) == 5242984);
  assert(div_int(20971940, 4) == 5242985);
  assert(div_int(20971944, 4) == 5242986);
  assert(div_int(20971948, 4) == 5242987);
  assert(div_int(20971952, 4) == 5242988);
  assert(div_int(20971956, 4) == 5242989);
  assert(div_int(20971960, 4) == 5242990);
  assert(div_int(20971964, 4) == 5242991);
  assert(div_int(20971968, 4) == 5242992);
  assert(div_int(20971972, 4) == 5242993);
  assert(div_int(20971976, 4) == 5242994);
  assert(div_int(20971980, 4) == 5242995);
  assert(div_int(20971984, 4) == 5242996);
  assert(div_int(20971992, 4) == 5242998);
  assert(div_int(20971996, 4) == 5242999);
  assert(div_int(20972004, 4) == 5243001);
  assert(div_int(20972008, 4) == 5243002);
  assert(div_int(20972012, 4) == 5243003);
  assert(div_int(20972016, 4) == 5243004);
  assert(div_int(20972020, 4) == 5243005);
  assert(div_int(20972024, 4) == 5243006);
  assert(div_int(20972028, 4) == 5243007);
  assert(div_int(20972032, 4) == 5243008);
  assert(div_int(20972036, 4) == 5243009);
  assert(div_int(20972040, 4) == 5243010);
  assert(div_int(20972044, 4) == 5243011);
  assert(div_int(20972048, 4) == 5243012);
  assert(div_int(20972052, 4) == 5243013);
  assert(div_int(20972060, 4) == 5243015);
  assert(div_int(20972064, 4) == 5243016);
  assert(div_int(20972076, 4) == 5243019);
  assert(div_int(20972080, 4) == 5243020);
  assert(div_int(20972084, 4) == 5243021);
  assert(div_int(20972088, 4) == 5243022);
  assert(div_int(20972092, 4) == 5243023);
  assert(div_int(20972096, 4) == 5243024);
  assert(div_int(20972100, 4) == 5243025);
  assert(div_int(20972104, 4) == 5243026);
  assert(div_int(20972108, 4) == 5243027);
  assert(div_int(20972112, 4) == 5243028);
  assert(div_int(20972116, 4) == 5243029);
  assert(div_int(20972120, 4) == 5243030);
  assert(div_int(20972124, 4) == 5243031);
  assert(div_int(20972128, 4) == 5243032);
  assert(div_int(20972132, 4) == 5243033);
  assert(div_int(20972136, 4) == 5243034);
  assert(div_int(20972140, 4) == 5243035);
  assert(div_int(20972144, 4) == 5243036);
  assert(div_int(20972148, 4) == 5243037);
  assert(div_int(20972152, 4) == 5243038);
  assert(div_int(20972156, 4) == 5243039);
  assert(div_int(20972160, 4) == 5243040);
  assert(div_int(20972164, 4) == 5243041);
  assert(div_int(20972168, 4) == 5243042);
  assert(div_int(20972172, 4) == 5243043);
  assert(div_int(20972176, 4) == 5243044);
  assert(div_int(20972180, 4) == 5243045);
  assert(div_int(20972184, 4) == 5243046);
  assert(div_int(20972188, 4) == 5243047);
  assert(div_int(20972192, 4) == 5243048);
  assert(div_int(20972196, 4) == 5243049);
  assert(div_int(20972200, 4) == 5243050);
  assert(div_int(20972204, 4) == 5243051);
  assert(div_int(20972208, 4) == 5243052);
  assert(div_int(20972212, 4) == 5243053);
  assert(div_int(20972216, 4) == 5243054);
  assert(div_int(20972220, 4) == 5243055);
  assert(div_int(20972224, 4) == 5243056);
  assert(div_int(20972228, 4) == 5243057);
  assert(div_int(20972232, 4) == 5243058);
  assert(div_int(20972236, 4) == 5243059);
  assert(div_int(20972240, 4) == 5243060);
  assert(div_int(20972244, 4) == 5243061);
  assert(div_int(20972248, 4) == 5243062);
  assert(div_int(20972252, 4) == 5243063);
  assert(div_int(20972256, 4) == 5243064);
  assert(div_int(20972260, 4) == 5243065);
  assert(div_int(20972264, 4) == 5243066);
  assert(div_int(20972268, 4) == 5243067);
  assert(div_int(20972272, 4) == 5243068);
  assert(div_int(20972276, 4) == 5243069);
  assert(div_int(20972280, 4) == 5243070);
  assert(div_int(20972284, 4) == 5243071);
  assert(div_int(20972288, 4) == 5243072);
  assert(div_int(20972292, 4) == 5243073);
  assert(div_int(20972296, 4) == 5243074);
  assert(div_int(20972300, 4) == 5243075);
  assert(div_int(20972304, 4) == 5243076);
  assert(div_int(20972308, 4) == 5243077);
  assert(div_int(20972312, 4) == 5243078);
  assert(div_int(20972316, 4) == 5243079);
  assert(div_int(20972320, 4) == 5243080);
  assert(div_int(20972324, 4) == 5243081);
  assert(div_int(20972328, 4) == 5243082);
  assert(div_int(20972332, 4) == 5243083);
  assert(div_int(20972336, 4) == 5243084);
  assert(div_int(20972340, 4) == 5243085);
  assert(div_int(20972344, 4) == 5243086);
  assert(div_int(20972348, 4) == 5243087);
  assert(div_int(20972352, 4) == 5243088);
  assert(div_int(20972356, 4) == 5243089);
  assert(div_int(20972360, 4) == 5243090);
  assert(div_int(20972364, 4) == 5243091);
  assert(div_int(20972368, 4) == 5243092);
  assert(div_int(20972372, 4) == 5243093);
  assert(div_int(20972376, 4) == 5243094);
  assert(div_int(20972380, 4) == 5243095);
  assert(div_int(20972384, 4) == 5243096);
  assert(div_int(20972388, 4) == 5243097);
  assert(div_int(20972392, 4) == 5243098);
  assert(div_int(20972396, 4) == 5243099);
  assert(div_int(20972400, 4) == 5243100);
  assert(div_int(20972404, 4) == 5243101);
  assert(div_int(20972408, 4) == 5243102);
  assert(div_int(20972412, 4) == 5243103);
  assert(div_int(20972416, 4) == 5243104);
  assert(div_int(20972420, 4) == 5243105);
  assert(div_int(20972424, 4) == 5243106);
  assert(div_int(20972428, 4) == 5243107);
  assert(div_int(20972432, 4) == 5243108);
  assert(div_int(20972436, 4) == 5243109);
  assert(div_int(20972440, 4) == 5243110);
  assert(div_int(20972444, 4) == 5243111);
  assert(div_int(20972448, 4) == 5243112);
  assert(div_int(20972452, 4) == 5243113);
  assert(div_int(20972456, 4) == 5243114);
  assert(div_int(20972460, 4) == 5243115);
  assert(div_int(20972464, 4) == 5243116);
  assert(div_int(20972472, 4) == 5243118);
  assert(div_int(20972476, 4) == 5243119);
  assert(div_int(20972484, 4) == 5243121);
  assert(div_int(20972488, 4) == 5243122);
  assert(div_int(20972492, 4) == 5243123);
  assert(div_int(20972496, 4) == 5243124);
  assert(div_int(20972500, 4) == 5243125);
  assert(div_int(20972504, 4) == 5243126);
  assert(div_int(20972508, 4) == 5243127);
  assert(div_int(20972512, 4) == 5243128);
  assert(div_int(20972516, 4) == 5243129);
  assert(div_int(20972520, 4) == 5243130);
  assert(div_int(20972524, 4) == 5243131);
  assert(div_int(20972532, 4) == 5243133);
  assert(div_int(20972536, 4) == 5243134);
  assert(div_int(20972548, 4) == 5243137);
  assert(div_int(20972552, 4) == 5243138);
  assert(div_int(20972556, 4) == 5243139);
  assert(div_int(20972560, 4) == 5243140);
  assert(div_int(20972564, 4) == 5243141);
  assert(div_int(20972568, 4) == 5243142);
  assert(div_int(20972572, 4) == 5243143);
  assert(div_int(20972576, 4) == 5243144);
  assert(div_int(20972580, 4) == 5243145);
  assert(div_int(20972584, 4) == 5243146);
  assert(div_int(20972588, 4) == 5243147);
  assert(div_int(20972592, 4) == 5243148);
  assert(div_int(20972596, 4) == 5243149);
  assert(div_int(20972600, 4) == 5243150);
  assert(div_int(20972604, 4) == 5243151);
  assert(div_int(20972608, 4) == 5243152);
  assert(div_int(20972612, 4) == 5243153);
  assert(div_int(20972616, 4) == 5243154);
  assert(div_int(20972620, 4) == 5243155);
  assert(div_int(20972624, 4) == 5243156);
  assert(div_int(20972628, 4) == 5243157);
  assert(div_int(20972632, 4) == 5243158);
  assert(div_int(20972636, 4) == 5243159);
  assert(div_int(20972640, 4) == 5243160);
  assert(div_int(20972644, 4) == 5243161);
  assert(div_int(20972648, 4) == 5243162);
  assert(div_int(20972652, 4) == 5243163);
  assert(div_int(20972656, 4) == 5243164);
  assert(div_int(20972660, 4) == 5243165);
  assert(div_int(20972664, 4) == 5243166);
  assert(div_int(20972668, 4) == 5243167);
  assert(div_int(20972672, 4) == 5243168);
  assert(div_int(20972676, 4) == 5243169);
  assert(div_int(20972680, 4) == 5243170);
  assert(div_int(20972684, 4) == 5243171);
  assert(div_int(20972688, 4) == 5243172);
  assert(div_int(20972692, 4) == 5243173);
  assert(div_int(20972696, 4) == 5243174);
  assert(div_int(20972700, 4) == 5243175);
  assert(div_int(20972704, 4) == 5243176);
  assert(div_int(20972708, 4) == 5243177);
  assert(div_int(20972712, 4) == 5243178);
  assert(div_int(20972716, 4) == 5243179);
  assert(div_int(20972720, 4) == 5243180);
  assert(div_int(20972724, 4) == 5243181);
  assert(div_int(20972728, 4) == 5243182);
  assert(div_int(20972732, 4) == 5243183);
  assert(div_int(20972736, 4) == 5243184);
  assert(div_int(20972740, 4) == 5243185);
  assert(div_int(20972744, 4) == 5243186);
  assert(div_int(20972748, 4) == 5243187);
  assert(div_int(20972752, 4) == 5243188);
  assert(div_int(20972756, 4) == 5243189);
  assert(div_int(20972760, 4) == 5243190);
  assert(div_int(20972764, 4) == 5243191);
  assert(div_int(20972768, 4) == 5243192);
  assert(div_int(20972772, 4) == 5243193);
  assert(div_int(20972776, 4) == 5243194);
  assert(div_int(20972780, 4) == 5243195);
  assert(div_int(20972784, 4) == 5243196);
  assert(div_int(20972788, 4) == 5243197);
  assert(div_int(20972792, 4) == 5243198);
  assert(div_int(20972796, 4) == 5243199);
  assert(div_int(20972800, 4) == 5243200);
  assert(div_int(20972808, 4) == 5243202);
  assert(div_int(20972812, 4) == 5243203);
  assert(div_int(20972820, 4) == 5243205);
  assert(div_int(20972824, 4) == 5243206);
  assert(div_int(20972828, 4) == 5243207);
  assert(div_int(20972832, 4) == 5243208);
  assert(div_int(20972836, 4) == 5243209);
  assert(div_int(20972840, 4) == 5243210);
  assert(div_int(20972844, 4) == 5243211);
  assert(div_int(20972848, 4) == 5243212);
  assert(div_int(20972852, 4) == 5243213);
  assert(div_int(20972856, 4) == 5243214);
  assert(div_int(20972860, 4) == 5243215);
  assert(div_int(20972868, 4) == 5243217);
  assert(div_int(20972872, 4) == 5243218);
  assert(div_int(20972884, 4) == 5243221);
  assert(div_int(20972888, 4) == 5243222);
  assert(div_int(20972892, 4) == 5243223);
  assert(div_int(20972896, 4) == 5243224);
  assert(div_int(20972900, 4) == 5243225);
  assert(div_int(20972904, 4) == 5243226);
  assert(div_int(20972908, 4) == 5243227);
  assert(div_int(20972912, 4) == 5243228);
  assert(div_int(20972916, 4) == 5243229);
  assert(div_int(20972920, 4) == 5243230);
  assert(div_int(20972924, 4) == 5243231);
  assert(div_int(20972928, 4) == 5243232);
  assert(div_int(20972932, 4) == 5243233);
  assert(div_int(20972936, 4) == 5243234);
  assert(div_int(20972940, 4) == 5243235);
  assert(div_int(20972944, 4) == 5243236);
  assert(div_int(20972948, 4) == 5243237);
  assert(div_int(20972952, 4) == 5243238);
  assert(div_int(20972956, 4) == 5243239);
  assert(div_int(20972960, 4) == 5243240);
  assert(div_int(20972964, 4) == 5243241);
  assert(div_int(20972968, 4) == 5243242);
  assert(div_int(20972972, 4) == 5243243);
  assert(div_int(20972976, 4) == 5243244);
  assert(div_int(20972980, 4) == 5243245);
  assert(div_int(20972984, 4) == 5243246);
  assert(div_int(20972988, 4) == 5243247);
  assert(div_int(20972992, 4) == 5243248);
  assert(div_int(20972996, 4) == 5243249);
  assert(div_int(20973000, 4) == 5243250);
  assert(div_int(20973004, 4) == 5243251);
  assert(div_int(20973008, 4) == 5243252);
  assert(div_int(20973012, 4) == 5243253);
  assert(div_int(20973016, 4) == 5243254);
  assert(div_int(20973020, 4) == 5243255);
  assert(div_int(20973024, 4) == 5243256);
  assert(div_int(20973028, 4) == 5243257);
  assert(div_int(20973032, 4) == 5243258);
  assert(div_int(20973036, 4) == 5243259);
  assert(div_int(20973040, 4) == 5243260);
  assert(div_int(20973044, 4) == 5243261);
  assert(div_int(20973048, 4) == 5243262);
  assert(div_int(20973052, 4) == 5243263);
  assert(div_int(20973056, 4) == 5243264);
  assert(div_int(20973060, 4) == 5243265);
  assert(div_int(20973064, 4) == 5243266);
  assert(div_int(20973068, 4) == 5243267);
  assert(div_int(20973072, 4) == 5243268);
  assert(div_int(20973076, 4) == 5243269);
  assert(div_int(20973080, 4) == 5243270);
  assert(div_int(20973084, 4) == 5243271);
  assert(div_int(20973088, 4) == 5243272);
  assert(div_int(20973092, 4) == 5243273);
  assert(div_int(20973096, 4) == 5243274);
  assert(div_int(20973100, 4) == 5243275);
  assert(div_int(20973104, 4) == 5243276);
  assert(div_int(20973108, 4) == 5243277);
  assert(div_int(20973112, 4) == 5243278);
  assert(div_int(20973116, 4) == 5243279);
  assert(div_int(20973120, 4) == 5243280);
  assert(div_int(20973124, 4) == 5243281);
  assert(div_int(20973128, 4) == 5243282);
  assert(div_int(20973132, 4) == 5243283);
  assert(div_int(20973136, 4) == 5243284);
  assert(div_int(20973144, 4) == 5243286);
  assert(div_int(20973148, 4) == 5243287);
  assert(div_int(20973156, 4) == 5243289);
  assert(div_int(20973160, 4) == 5243290);
  assert(div_int(20973164, 4) == 5243291);
  assert(div_int(20973168, 4) == 5243292);
  assert(div_int(20973172, 4) == 5243293);
  assert(div_int(20973176, 4) == 5243294);
  assert(div_int(20973180, 4) == 5243295);
  assert(div_int(20973184, 4) == 5243296);
  assert(div_int(20973188, 4) == 5243297);
  assert(div_int(20973192, 4) == 5243298);
  assert(div_int(20973196, 4) == 5243299);
  assert(div_int(20973204, 4) == 5243301);
  assert(div_int(20973208, 4) == 5243302);
  assert(div_int(20973220, 4) == 5243305);
  assert(div_int(20973224, 4) == 5243306);
  assert(div_int(20973228, 4) == 5243307);
  assert(div_int(20973232, 4) == 5243308);
  assert(div_int(20973236, 4) == 5243309);
  assert(div_int(20973240, 4) == 5243310);
  assert(div_int(20973244, 4) == 5243311);
  assert(div_int(20973248, 4) == 5243312);
  assert(div_int(20973252, 4) == 5243313);
  assert(div_int(20973256, 4) == 5243314);
  assert(div_int(20973260, 4) == 5243315);
  assert(div_int(20973264, 4) == 5243316);
  assert(div_int(20973268, 4) == 5243317);
  assert(div_int(20973272, 4) == 5243318);
  assert(div_int(20973276, 4) == 5243319);
  assert(div_int(20973280, 4) == 5243320);
  assert(div_int(20973284, 4) == 5243321);
  assert(div_int(20973288, 4) == 5243322);
  assert(div_int(20973292, 4) == 5243323);
  assert(div_int(20973296, 4) == 5243324);
  assert(div_int(20973300, 4) == 5243325);
  assert(div_int(20973304, 4) == 5243326);
  assert(div_int(20973308, 4) == 5243327);
  assert(div_int(20973312, 4) == 5243328);
  assert(div_int(20973316, 4) == 5243329);
  assert(div_int(20973320, 4) == 5243330);
  assert(div_int(20973324, 4) == 5243331);
  assert(div_int(20973328, 4) == 5243332);
  assert(div_int(20973332, 4) == 5243333);
  assert(div_int(20973348, 4) == 5243337);
  assert(div_int(20973352, 4) == 5243338);
  assert(div_int(20973356, 4) == 5243339);
  assert(div_int(20973360, 4) == 5243340);
  assert(div_int(20973364, 4) == 5243341);
  assert(div_int(20973368, 4) == 5243342);
  assert(div_int(20973372, 4) == 5243343);
  assert(div_int(20973376, 4) == 5243344);
  assert(div_int(20973380, 4) == 5243345);
  assert(div_int(20973384, 4) == 5243346);
  assert(div_int(20973388, 4) == 5243347);
  assert(div_int(20973392, 4) == 5243348);
  assert(div_int(20973396, 4) == 5243349);
  assert(div_int(20973400, 4) == 5243350);
  assert(div_int(20973404, 4) == 5243351);
  assert(div_int(20973408, 4) == 5243352);
  assert(div_int(20973412, 4) == 5243353);
  assert(div_int(20973416, 4) == 5243354);
  assert(div_int(20973420, 4) == 5243355);
  assert(div_int(20973424, 4) == 5243356);
  assert(div_int(20973428, 4) == 5243357);
  assert(div_int(20973432, 4) == 5243358);
  assert(div_int(20973436, 4) == 5243359);
  assert(div_int(20973440, 4) == 5243360);
  assert(div_int(20973444, 4) == 5243361);
  assert(div_int(20973448, 4) == 5243362);
  assert(div_int(20973452, 4) == 5243363);
  assert(div_int(20973456, 4) == 5243364);
  assert(div_int(20973460, 4) == 5243365);
  assert(div_int(20973464, 4) == 5243366);
  assert(div_int(20973468, 4) == 5243367);
  assert(div_int(20973476, 4) == 5243369);
  assert(div_int(20973480, 4) == 5243370);
  assert(div_int(20973488, 4) == 5243372);
  assert(div_int(20973492, 4) == 5243373);
  assert(div_int(20973496, 4) == 5243374);
  assert(div_int(20973500, 4) == 5243375);
  assert(div_int(20973504, 4) == 5243376);
  assert(div_int(20973508, 4) == 5243377);
  assert(div_int(20973512, 4) == 5243378);
  assert(div_int(20973516, 4) == 5243379);
  assert(div_int(20973520, 4) == 5243380);
  assert(div_int(20973524, 4) == 5243381);
  assert(div_int(20973528, 4) == 5243382);
  assert(div_int(20973536, 4) == 5243384);
  assert(div_int(20973540, 4) == 5243385);
  assert(div_int(20973552, 4) == 5243388);
  assert(div_int(20973556, 4) == 5243389);
  assert(div_int(20973560, 4) == 5243390);
  assert(div_int(20973564, 4) == 5243391);
  assert(div_int(20973568, 4) == 5243392);
  assert(div_int(20973572, 4) == 5243393);
  assert(div_int(20973576, 4) == 5243394);
  assert(div_int(20973580, 4) == 5243395);
  assert(div_int(20973584, 4) == 5243396);
  assert(div_int(20973588, 4) == 5243397);
  assert(div_int(20973592, 4) == 5243398);
  assert(div_int(20973596, 4) == 5243399);
  assert(div_int(20973600, 4) == 5243400);
  assert(div_int(20973604, 4) == 5243401);
  assert(div_int(20973608, 4) == 5243402);
  assert(div_int(20973612, 4) == 5243403);
  assert(div_int(20973616, 4) == 5243404);
  assert(div_int(20973620, 4) == 5243405);
  assert(div_int(20973624, 4) == 5243406);
  assert(div_int(20973628, 4) == 5243407);
  assert(div_int(20973632, 4) == 5243408);
  assert(div_int(20973636, 4) == 5243409);
  assert(div_int(20973640, 4) == 5243410);
  assert(div_int(20973644, 4) == 5243411);
  assert(div_int(20973648, 4) == 5243412);
  assert(div_int(20973652, 4) == 5243413);
  assert(div_int(20973656, 4) == 5243414);
  assert(div_int(20973660, 4) == 5243415);
  assert(div_int(20973664, 4) == 5243416);
  assert(div_int(20973668, 4) == 5243417);
  assert(div_int(20973672, 4) == 5243418);
  assert(div_int(20973676, 4) == 5243419);
  assert(div_int(20973680, 4) == 5243420);
  assert(div_int(20973684, 4) == 5243421);
  assert(div_int(20973688, 4) == 5243422);
  assert(div_int(20973692, 4) == 5243423);
  assert(div_int(20973696, 4) == 5243424);
  assert(div_int(20973700, 4) == 5243425);
  assert(div_int(20973704, 4) == 5243426);
  assert(div_int(20973708, 4) == 5243427);
  assert(div_int(20973712, 4) == 5243428);
  assert(div_int(20973716, 4) == 5243429);
  assert(div_int(20973720, 4) == 5243430);
  assert(div_int(20973724, 4) == 5243431);
  assert(div_int(20973728, 4) == 5243432);
  assert(div_int(20973732, 4) == 5243433);
  assert(div_int(20973736, 4) == 5243434);
  assert(div_int(20973740, 4) == 5243435);
  assert(div_int(20973744, 4) == 5243436);
  assert(div_int(20973748, 4) == 5243437);
  assert(div_int(20973752, 4) == 5243438);
  assert(div_int(20973756, 4) == 5243439);
  assert(div_int(20973760, 4) == 5243440);
  assert(div_int(20973764, 4) == 5243441);
  assert(div_int(20973768, 4) == 5243442);
  assert(div_int(20973772, 4) == 5243443);
  assert(div_int(20973776, 4) == 5243444);
  assert(div_int(20973780, 4) == 5243445);
  assert(div_int(20973784, 4) == 5243446);
  assert(div_int(20973788, 4) == 5243447);
  assert(div_int(20973792, 4) == 5243448);
  assert(div_int(20973796, 4) == 5243449);
  assert(div_int(20973800, 4) == 5243450);
  assert(div_int(20973804, 4) == 5243451);
  assert(div_int(20973808, 4) == 5243452);
  assert(div_int(20973812, 4) == 5243453);
  assert(div_int(20973816, 4) == 5243454);
  assert(div_int(20973820, 4) == 5243455);
  assert(div_int(20973824, 4) == 5243456);
  assert(div_int(20973828, 4) == 5243457);
  assert(div_int(20973832, 4) == 5243458);
  assert(div_int(20973836, 4) == 5243459);
  assert(div_int(20973840, 4) == 5243460);
  assert(div_int(20973844, 4) == 5243461);
  assert(div_int(20973848, 4) == 5243462);
  assert(div_int(20973852, 4) == 5243463);
  assert(div_int(20973856, 4) == 5243464);
  assert(div_int(20973860, 4) == 5243465);
  assert(div_int(20973864, 4) == 5243466);
  assert(div_int(20973868, 4) == 5243467);
  assert(div_int(20973872, 4) == 5243468);
  assert(div_int(21006064, 4) == 5251516);
  assert(div_int(21006068, 4) == 5251517);
  assert(div_int(21006072, 4) == 5251518);
  assert(div_int(21006396, 4) == 5251599);
  assert(div_int(21006400, 4) == 5251600);
  assert(div_int(21006404, 4) == 5251601);
  assert(div_int(213056, 8) == 26632);
  assert(div_int(22020856, 4) == 5505214);
  assert(div_int(22020860, 4) == 5505215);
  assert(div_int(22020864, 4) == 5505216);
  assert(div_int(22021200, 4) == 5505300);
  assert(div_int(22021204, 4) == 5505301);
  assert(div_int(22021208, 4) == 5505302);
  assert(div_int(22021536, 4) == 5505384);
  assert(div_int(22021540, 4) == 5505385);
  assert(div_int(22021544, 4) == 5505386);
  assert(div_int(271581184, 4) == 67895296);
  assert(div_int(271581188, 4) == 67895297);
  assert(div_int(271581192, 4) == 67895298);
  assert(div_int(271581200, 8) == 33947650);
  assert(div_int(272630316, 4) == 68157579);
  assert(div_int(272630320, 4) == 68157580);
  assert(div_int(272630324, 4) == 68157581);
  assert(div_int(272630328, 4) == 68157582);
  assert(div_int(272630332, 4) == 68157583);
  assert(div_int(272630336, 4) == 68157584);
  assert(div_int(272630340, 4) == 68157585);
  assert(div_int(272630344, 4) == 68157586);
  assert(div_int(272634400, 4) == 68158600);
  assert(div_int(272634404, 4) == 68158601);
  assert(div_int(272634408, 4) == 68158602);
  assert(div_int(272634412, 4) == 68158603);
  assert(div_int(272634416, 4) == 68158604);
  assert(div_int(272634420, 4) == 68158605);
  assert(div_int(272634424, 4) == 68158606);
  assert(div_int(272638496, 4) == 68159624);
  assert(div_int(272638500, 4) == 68159625);
  assert(div_int(272638504, 4) == 68159626);
  assert(div_int(272638508, 4) == 68159627);
  assert(div_int(272638512, 4) == 68159628);
  assert(div_int(272638516, 4) == 68159629);
  assert(div_int(272638520, 4) == 68159630);
  assert(div_int(304087160, 4) == 76021790);
  assert(div_int(304087164, 4) == 76021791);
  assert(div_int(304087168, 4) == 76021792);
  assert(div_int(307232768, 4) == 76808192);
  assert(div_int(307232772, 4) == 76808193);
  assert(div_int(307232776, 8) == 38404097);
  assert(div_int(307232784, 4) == 76808196);
  assert(div_int(307232788, 4) == 76808197);
  assert(div_int(307232792, 8) == 38404099);
  assert(div_int(307232800, 4) == 76808200);
  assert(div_int(307232804, 4) == 76808201);
  assert(div_int(307232808, 8) == 38404101);
  assert(div_int(307232816, 4) == 76808204);
  assert(div_int(307232820, 4) == 76808205);
  assert(div_int(307232824, 8) == 38404103);
  assert(div_int(307232832, 4) == 76808208);
  assert(div_int(307232836, 4) == 76808209);
  assert(div_int(307232840, 4) == 76808210);
  assert(div_int(307232844, 4) == 76808211);
  assert(div_int(307232848, 4) == 76808212);
  assert(div_int(307232852, 4) == 76808213);
  assert(div_int(307232856, 4) == 76808214);
  assert(div_int(307232860, 4) == 76808215);
  assert(div_int(307232864, 4) == 76808216);
  assert(div_int(307232868, 4) == 76808217);
  assert(div_int(307232872, 4) == 76808218);
  assert(div_int(307232876, 4) == 76808219);
  assert(div_int(307232880, 4) == 76808220);
  assert(div_int(307232884, 4) == 76808221);
  assert(div_int(307232888, 4) == 76808222);
  assert(div_int(307232892, 4) == 76808223);
  assert(div_int(307232896, 4) == 76808224);
  assert(div_int(307232900, 4) == 76808225);
  assert(div_int(307232904, 4) == 76808226);
  assert(div_int(307232908, 4) == 76808227);
  assert(div_int(307232912, 4) == 76808228);
  assert(div_int(307232916, 4) == 76808229);
  assert(div_int(307232920, 4) == 76808230);
  assert(div_int(308281344, 4) == 77070336);
  assert(div_int(308281348, 4) == 77070337);
  assert(div_int(308281352, 8) == 38535169);
  assert(div_int(308281360, 4) == 77070340);
  assert(div_int(308281364, 4) == 77070341);
  assert(div_int(308281368, 8) == 38535171);
  assert(div_int(308281376, 4) == 77070344);
  assert(div_int(308281380, 4) == 77070345);
  assert(div_int(308281384, 8) == 38535173);
  assert(div_int(308281392, 4) == 77070348);
  assert(div_int(308281396, 4) == 77070349);
  assert(div_int(308281400, 8) == 38535175);
  assert(div_int(308281408, 4) == 77070352);
  assert(div_int(308281412, 4) == 77070353);
  assert(div_int(308281416, 8) == 38535177);
  assert(div_int(308281424, 4) == 77070356);
  assert(div_int(308281428, 4) == 77070357);
  assert(div_int(308281432, 4) == 77070358);
  assert(div_int(308281436, 4) == 77070359);
  assert(div_int(308281440, 4) == 77070360);
  assert(div_int(308281444, 4) == 77070361);
  assert(div_int(308281448, 4) == 77070362);
  assert(div_int(308281452, 4) == 77070363);
  assert(div_int(308281456, 4) == 77070364);
  assert(div_int(308281460, 4) == 77070365);
  assert(div_int(308281464, 4) == 77070366);
  assert(div_int(308281468, 4) == 77070367);
  assert(div_int(308281472, 4) == 77070368);
  assert(div_int(308281476, 4) == 77070369);
  assert(div_int(308281480, 4) == 77070370);
  assert(div_int(308281484, 4) == 77070371);
  assert(div_int(308281488, 4) == 77070372);
  assert(div_int(308281492, 4) == 77070373);
  assert(div_int(308281496, 4) == 77070374);
  assert(div_int(308281500, 4) == 77070375);
  assert(div_int(308281504, 4) == 77070376);
  assert(div_int(308281508, 4) == 77070377);
  assert(div_int(308281512, 4) == 77070378);
  assert(div_int(313344, 8) == 39168);
  assert(div_int(3145728, 1) == 3145728);
  assert(div_int(3145729, 1) == 3145729);
  assert(div_int(3145730, 1) == 3145730);
  assert(div_int(3145731, 1) == 3145731);
  assert(div_int(3145732, 1) == 3145732);
  assert(div_int(3145733, 1) == 3145733);
  assert(div_int(3145734, 1) == 3145734);
  assert(div_int(3145735, 1) == 3145735);
  assert(div_int(3145736, 1) == 3145736);
  assert(div_int(3145737, 1) == 3145737);
  assert(div_int(3145738, 1) == 3145738);
  assert(div_int(3145739, 1) == 3145739);
  assert(div_int(3145740, 1) == 3145740);
  assert(div_int(3145741, 1) == 3145741);
  assert(div_int(3145742, 1) == 3145742);
  assert(div_int(318767104, 1) == 318767104);
  assert(div_int(32, 8) == 4);
  assert(div_int(32832, 8) == 4104);
  assert(div_int(344064, 8) == 43008);
  assert(div_int(360448, 8) == 45056);
  assert(div_int(376896, 8) == 47112);
  assert(div_int(442499192, 4) == 110624798);
  assert(div_int(442499196, 4) == 110624799);
  assert(div_int(442499200, 4) == 110624800);
  assert(div_int(48234496, 8) == 6029312);
  assert(div_int(48234504, 8) == 6029313);
  assert(div_int(48234512, 8) == 6029314);
  assert(div_int(48234520, 8) == 6029315);
  assert(div_int(48234528, 8) == 6029316);
  assert(div_int(48234536, 8) == 6029317);
  assert(div_int(48234544, 8) == 6029318);
  assert(div_int(48234552, 8) == 6029319);
  assert(div_int(48234560, 8) == 6029320);
  assert(div_int(48234568, 8) == 6029321);
  assert(div_int(48234576, 8) == 6029322);
  assert(div_int(48234584, 8) == 6029323);
  assert(div_int(48234592, 8) == 6029324);
  assert(div_int(48234600, 8) == 6029325);
  assert(div_int(48234608, 8) == 6029326);
  assert(div_int(48234616, 8) == 6029327);
  assert(div_int(48234624, 8) == 6029328);
  assert(div_int(48234632, 8) == 6029329);
  assert(div_int(48234640, 8) == 6029330);
  assert(div_int(48234648, 8) == 6029331);
  assert(div_int(48234656, 8) == 6029332);
  assert(div_int(48234664, 8) == 6029333);
  assert(div_int(48234672, 8) == 6029334);
  assert(div_int(48234680, 8) == 6029335);
  assert(div_int(48234688, 8) == 6029336);
  assert(div_int(48234696, 8) == 6029337);
  assert(div_int(48234704, 8) == 6029338);
  assert(div_int(48234712, 8) == 6029339);
  assert(div_int(48234720, 8) == 6029340);
  assert(div_int(48234728, 8) == 6029341);
  assert(div_int(48234736, 8) == 6029342);
  assert(div_int(48234744, 8) == 6029343);
  assert(div_int(48234752, 8) == 6029344);
  assert(div_int(48234760, 8) == 6029345);
  assert(div_int(48234768, 8) == 6029346);
  assert(div_int(48234776, 8) == 6029347);
  assert(div_int(48234784, 8) == 6029348);
  assert(div_int(48234792, 8) == 6029349);
  assert(div_int(48234800, 8) == 6029350);
  assert(div_int(48234808, 8) == 6029351);
  assert(div_int(48234816, 8) == 6029352);
  assert(div_int(48234824, 8) == 6029353);
  assert(div_int(48234832, 8) == 6029354);
  assert(div_int(48234840, 8) == 6029355);
  assert(div_int(48234848, 8) == 6029356);
  assert(div_int(48234856, 8) == 6029357);
  assert(div_int(48234864, 8) == 6029358);
  assert(div_int(48234872, 8) == 6029359);
  assert(div_int(48234880, 8) == 6029360);
  assert(div_int(48234888, 8) == 6029361);
  assert(div_int(48234896, 8) == 6029362);
  assert(div_int(48234904, 8) == 6029363);
  assert(div_int(48234912, 8) == 6029364);
  assert(div_int(48234920, 8) == 6029365);
  assert(div_int(48234928, 8) == 6029366);
  assert(div_int(48234936, 8) == 6029367);
  assert(div_int(48234944, 8) == 6029368);
  assert(div_int(48234952, 8) == 6029369);
  assert(div_int(48234960, 8) == 6029370);
  assert(div_int(48234968, 8) == 6029371);
  assert(div_int(48234976, 8) == 6029372);
  assert(div_int(48234984, 8) == 6029373);
  assert(div_int(48234992, 8) == 6029374);
  assert(div_int(48235000, 8) == 6029375);
  assert(div_int(48235008, 8) == 6029376);
  assert(div_int(48235016, 8) == 6029377);
  assert(div_int(48235024, 8) == 6029378);
  assert(div_int(48235032, 8) == 6029379);
  assert(div_int(48235040, 8) == 6029380);
  assert(div_int(48235048, 8) == 6029381);
  assert(div_int(48235056, 8) == 6029382);
  assert(div_int(48235064, 8) == 6029383);
  assert(div_int(48235072, 8) == 6029384);
  assert(div_int(48235080, 8) == 6029385);
  assert(div_int(48235088, 8) == 6029386);
  assert(div_int(48235096, 8) == 6029387);
  assert(div_int(48235104, 8) == 6029388);
  assert(div_int(48235112, 8) == 6029389);
  assert(div_int(48235120, 8) == 6029390);
  assert(div_int(48235128, 8) == 6029391);
  assert(div_int(48235136, 8) == 6029392);
  assert(div_int(48235144, 8) == 6029393);
  assert(div_int(48235152, 8) == 6029394);
  assert(div_int(48235160, 8) == 6029395);
  assert(div_int(48235168, 8) == 6029396);
  assert(div_int(48235176, 8) == 6029397);
  assert(div_int(48235184, 8) == 6029398);
  assert(div_int(48235192, 8) == 6029399);
  assert(div_int(48235200, 8) == 6029400);
  assert(div_int(48235208, 8) == 6029401);
  assert(div_int(48235216, 8) == 6029402);
  assert(div_int(48235224, 8) == 6029403);
  assert(div_int(48235232, 8) == 6029404);
  assert(div_int(48235240, 8) == 6029405);
  assert(div_int(48235248, 8) == 6029406);
  assert(div_int(48235256, 8) == 6029407);
  assert(div_int(48235264, 8) == 6029408);
  assert(div_int(48235272, 8) == 6029409);
  assert(div_int(48235280, 8) == 6029410);
  assert(div_int(48235288, 8) == 6029411);
  assert(div_int(48235296, 8) == 6029412);
  assert(div_int(48235304, 8) == 6029413);
  assert(div_int(48235312, 8) == 6029414);
  assert(div_int(48235320, 8) == 6029415);
  assert(div_int(48235328, 8) == 6029416);
  assert(div_int(48235336, 8) == 6029417);
  assert(div_int(48235344, 8) == 6029418);
  assert(div_int(48235352, 8) == 6029419);
  assert(div_int(48235360, 8) == 6029420);
  assert(div_int(48235368, 8) == 6029421);
  assert(div_int(48235376, 8) == 6029422);
  assert(div_int(48235384, 8) == 6029423);
  assert(div_int(48235392, 8) == 6029424);
  assert(div_int(48235400, 8) == 6029425);
  assert(div_int(48235408, 8) == 6029426);
  assert(div_int(48235416, 8) == 6029427);
  assert(div_int(48235424, 8) == 6029428);
  assert(div_int(48235432, 8) == 6029429);
  assert(div_int(48235440, 8) == 6029430);
  assert(div_int(48235448, 8) == 6029431);
  assert(div_int(48235456, 8) == 6029432);
  assert(div_int(48235464, 8) == 6029433);
  assert(div_int(48235472, 8) == 6029434);
  assert(div_int(48235480, 8) == 6029435);
  assert(div_int(48235488, 8) == 6029436);
  assert(div_int(48235496, 8) == 6029437);
  assert(div_int(48235504, 8) == 6029438);
  assert(div_int(48235512, 8) == 6029439);
  assert(div_int(48235520, 8) == 6029440);
  assert(div_int(48235528, 8) == 6029441);
  assert(div_int(48235536, 8) == 6029442);
  assert(div_int(48235544, 8) == 6029443);
  assert(div_int(48235552, 8) == 6029444);
  assert(div_int(48235560, 8) == 6029445);
  assert(div_int(48235568, 8) == 6029446);
  assert(div_int(48235576, 8) == 6029447);
  assert(div_int(48235584, 8) == 6029448);
  assert(div_int(48235592, 8) == 6029449);
  assert(div_int(48235600, 8) == 6029450);
  assert(div_int(48235608, 8) == 6029451);
  assert(div_int(48235616, 8) == 6029452);
  assert(div_int(48235624, 8) == 6029453);
  assert(div_int(48235632, 8) == 6029454);
  assert(div_int(48235640, 8) == 6029455);
  assert(div_int(48235648, 8) == 6029456);
  assert(div_int(48235656, 8) == 6029457);
  assert(div_int(48235664, 8) == 6029458);
  assert(div_int(48235672, 8) == 6029459);
  assert(div_int(48235680, 8) == 6029460);
  assert(div_int(48235688, 8) == 6029461);
  assert(div_int(48235696, 8) == 6029462);
  assert(div_int(48235704, 8) == 6029463);
  assert(div_int(48235712, 8) == 6029464);
  assert(div_int(48235720, 8) == 6029465);
  assert(div_int(48235728, 8) == 6029466);
  assert(div_int(48235736, 8) == 6029467);
  assert(div_int(48235744, 8) == 6029468);
  assert(div_int(48235752, 8) == 6029469);
  assert(div_int(48235760, 8) == 6029470);
  assert(div_int(48235768, 8) == 6029471);
  assert(div_int(48235776, 8) == 6029472);
  assert(div_int(48235784, 8) == 6029473);
  assert(div_int(48235792, 8) == 6029474);
  assert(div_int(48235800, 8) == 6029475);
  assert(div_int(48235808, 8) == 6029476);
  assert(div_int(48235816, 8) == 6029477);
  assert(div_int(48238592, 8) == 6029824);
  assert(div_int(48238600, 8) == 6029825);
  assert(div_int(48238608, 8) == 6029826);
  assert(div_int(48238616, 8) == 6029827);
  assert(div_int(48238624, 8) == 6029828);
  assert(div_int(48238632, 8) == 6029829);
  assert(div_int(48238640, 8) == 6029830);
  assert(div_int(48238648, 8) == 6029831);
  assert(div_int(48238656, 8) == 6029832);
  assert(div_int(48238664, 8) == 6029833);
  assert(div_int(48238672, 8) == 6029834);
  assert(div_int(48238680, 8) == 6029835);
  assert(div_int(48238688, 8) == 6029836);
  assert(div_int(48238696, 8) == 6029837);
  assert(div_int(48238704, 8) == 6029838);
  assert(div_int(48238712, 8) == 6029839);
  assert(div_int(48238720, 8) == 6029840);
  assert(div_int(48238728, 8) == 6029841);
  assert(div_int(48238736, 8) == 6029842);
  assert(div_int(48238744, 8) == 6029843);
  assert(div_int(48238752, 8) == 6029844);
  assert(div_int(48238760, 8) == 6029845);
  assert(div_int(48238768, 8) == 6029846);
  assert(div_int(48238776, 8) == 6029847);
  assert(div_int(48238784, 8) == 6029848);
  assert(div_int(48238792, 8) == 6029849);
  assert(div_int(48238800, 8) == 6029850);
  assert(div_int(48238808, 8) == 6029851);
  assert(div_int(48238816, 8) == 6029852);
  assert(div_int(48238824, 8) == 6029853);
  assert(div_int(48238832, 8) == 6029854);
  assert(div_int(48238840, 8) == 6029855);
  assert(div_int(48238848, 8) == 6029856);
  assert(div_int(48238856, 8) == 6029857);
  assert(div_int(48238864, 8) == 6029858);
  assert(div_int(48238872, 8) == 6029859);
  assert(div_int(48238880, 8) == 6029860);
  assert(div_int(48238888, 8) == 6029861);
  assert(div_int(48238896, 8) == 6029862);
  assert(div_int(48238904, 8) == 6029863);
  assert(div_int(48238912, 8) == 6029864);
  assert(div_int(48238920, 8) == 6029865);
  assert(div_int(48238928, 8) == 6029866);
  assert(div_int(48238936, 8) == 6029867);
  assert(div_int(48238944, 8) == 6029868);
  assert(div_int(48238952, 8) == 6029869);
  assert(div_int(48238960, 8) == 6029870);
  assert(div_int(48238968, 8) == 6029871);
  assert(div_int(48238976, 8) == 6029872);
  assert(div_int(48238984, 8) == 6029873);
  assert(div_int(48238992, 8) == 6029874);
  assert(div_int(48239000, 8) == 6029875);
  assert(div_int(48239008, 8) == 6029876);
  assert(div_int(48239016, 8) == 6029877);
  assert(div_int(48239024, 8) == 6029878);
  assert(div_int(48239032, 8) == 6029879);
  assert(div_int(48239040, 8) == 6029880);
  assert(div_int(48239048, 8) == 6029881);
  assert(div_int(48239056, 8) == 6029882);
  assert(div_int(48239064, 8) == 6029883);
  assert(div_int(48239072, 8) == 6029884);
  assert(div_int(48239080, 8) == 6029885);
  assert(div_int(48239088, 8) == 6029886);
  assert(div_int(48239096, 8) == 6029887);
  assert(div_int(48239104, 8) == 6029888);
  assert(div_int(48239112, 8) == 6029889);
  assert(div_int(48239120, 8) == 6029890);
  assert(div_int(48239128, 8) == 6029891);
  assert(div_int(48239136, 8) == 6029892);
  assert(div_int(48239144, 8) == 6029893);
  assert(div_int(48239152, 8) == 6029894);
  assert(div_int(48239160, 8) == 6029895);
  assert(div_int(48239168, 8) == 6029896);
  assert(div_int(48239176, 8) == 6029897);
  assert(div_int(48239184, 8) == 6029898);
  assert(div_int(48239192, 8) == 6029899);
  assert(div_int(48239200, 8) == 6029900);
  assert(div_int(48239208, 8) == 6029901);
  assert(div_int(48239216, 8) == 6029902);
  assert(div_int(48239224, 8) == 6029903);
  assert(div_int(48239232, 8) == 6029904);
  assert(div_int(48239240, 8) == 6029905);
  assert(div_int(48239248, 8) == 6029906);
  assert(div_int(48239256, 8) == 6029907);
  assert(div_int(48239264, 8) == 6029908);
  assert(div_int(48239272, 8) == 6029909);
  assert(div_int(48239280, 8) == 6029910);
  assert(div_int(48239288, 8) == 6029911);
  assert(div_int(48239296, 8) == 6029912);
  assert(div_int(48239304, 8) == 6029913);
  assert(div_int(48239312, 8) == 6029914);
  assert(div_int(48239320, 8) == 6029915);
  assert(div_int(48239328, 8) == 6029916);
  assert(div_int(48239336, 8) == 6029917);
  assert(div_int(48239344, 8) == 6029918);
  assert(div_int(48239352, 8) == 6029919);
  assert(div_int(48239360, 8) == 6029920);
  assert(div_int(48239368, 8) == 6029921);
  assert(div_int(48239376, 8) == 6029922);
  assert(div_int(48239384, 8) == 6029923);
  assert(div_int(48239392, 8) == 6029924);
  assert(div_int(48239400, 8) == 6029925);
  assert(div_int(48239408, 8) == 6029926);
  assert(div_int(48239416, 8) == 6029927);
  assert(div_int(48239424, 8) == 6029928);
  assert(div_int(48239432, 8) == 6029929);
  assert(div_int(48239440, 8) == 6029930);
  assert(div_int(48239448, 8) == 6029931);
  assert(div_int(48239456, 8) == 6029932);
  assert(div_int(48239464, 8) == 6029933);
  assert(div_int(48239472, 8) == 6029934);
  assert(div_int(48239480, 8) == 6029935);
  assert(div_int(48239488, 8) == 6029936);
  assert(div_int(48239496, 8) == 6029937);
  assert(div_int(48239504, 8) == 6029938);
  assert(div_int(48239512, 8) == 6029939);
  assert(div_int(48239520, 8) == 6029940);
  assert(div_int(48239528, 8) == 6029941);
  assert(div_int(48239536, 8) == 6029942);
  assert(div_int(48239544, 8) == 6029943);
  assert(div_int(48239552, 8) == 6029944);
  assert(div_int(48239560, 8) == 6029945);
  assert(div_int(48239568, 8) == 6029946);
  assert(div_int(48239576, 8) == 6029947);
  assert(div_int(48239584, 8) == 6029948);
  assert(div_int(48239592, 8) == 6029949);
  assert(div_int(48239600, 8) == 6029950);
  assert(div_int(48239608, 8) == 6029951);
  assert(div_int(48239616, 8) == 6029952);
  assert(div_int(48239624, 8) == 6029953);
  assert(div_int(48239632, 8) == 6029954);
  assert(div_int(48239640, 8) == 6029955);
  assert(div_int(48239648, 8) == 6029956);
  assert(div_int(48239656, 8) == 6029957);
  assert(div_int(48239664, 8) == 6029958);
  assert(div_int(48239672, 8) == 6029959);
  assert(div_int(48239680, 8) == 6029960);
  assert(div_int(48239688, 8) == 6029961);
  assert(div_int(48239696, 8) == 6029962);
  assert(div_int(48239704, 8) == 6029963);
  assert(div_int(48239712, 8) == 6029964);
  assert(div_int(48239720, 8) == 6029965);
  assert(div_int(48239728, 8) == 6029966);
  assert(div_int(48239736, 8) == 6029967);
  assert(div_int(48239744, 8) == 6029968);
  assert(div_int(48239752, 8) == 6029969);
  assert(div_int(48239760, 8) == 6029970);
  assert(div_int(48239768, 8) == 6029971);
  assert(div_int(48239776, 8) == 6029972);
  assert(div_int(48239784, 8) == 6029973);
  assert(div_int(48239792, 8) == 6029974);
  assert(div_int(48239800, 8) == 6029975);
  assert(div_int(48239808, 8) == 6029976);
  assert(div_int(48239816, 8) == 6029977);
  assert(div_int(48239824, 8) == 6029978);
  assert(div_int(48239832, 8) == 6029979);
  assert(div_int(48239840, 8) == 6029980);
  assert(div_int(48239848, 8) == 6029981);
  assert(div_int(48239856, 8) == 6029982);
  assert(div_int(48239864, 8) == 6029983);
  assert(div_int(48239872, 8) == 6029984);
  assert(div_int(48239880, 8) == 6029985);
  assert(div_int(48239888, 8) == 6029986);
  assert(div_int(48239896, 8) == 6029987);
  assert(div_int(48239904, 8) == 6029988);
  assert(div_int(48239912, 8) == 6029989);
  assert(div_int(48239920, 8) == 6029990);
  assert(div_int(48239928, 8) == 6029991);
  assert(div_int(48239936, 8) == 6029992);
  assert(div_int(48239944, 8) == 6029993);
  assert(div_int(48239952, 8) == 6029994);
  assert(div_int(48239960, 8) == 6029995);
  assert(div_int(48239968, 8) == 6029996);
  assert(div_int(48239976, 8) == 6029997);
  assert(div_int(48239984, 8) == 6029998);
  assert(div_int(48239992, 8) == 6029999);
  assert(div_int(48240000, 8) == 6030000);
  assert(div_int(48240008, 8) == 6030001);
  assert(div_int(48240016, 8) == 6030002);
  assert(div_int(48240024, 8) == 6030003);
  assert(div_int(48240032, 8) == 6030004);
  assert(div_int(48240040, 8) == 6030005);
  assert(div_int(48240048, 8) == 6030006);
  assert(div_int(48240056, 8) == 6030007);
  assert(div_int(48240064, 8) == 6030008);
  assert(div_int(48240072, 8) == 6030009);
  assert(div_int(48240080, 8) == 6030010);
  assert(div_int(48240088, 8) == 6030011);
  assert(div_int(48240096, 8) == 6030012);
  assert(div_int(48240104, 8) == 6030013);
  assert(div_int(48240112, 8) == 6030014);
  assert(div_int(48240120, 8) == 6030015);
  assert(div_int(48240128, 8) == 6030016);
  assert(div_int(48240136, 8) == 6030017);
  assert(div_int(48240144, 8) == 6030018);
  assert(div_int(48240152, 8) == 6030019);
}