payload-imaging-gaussian-blur-gaussianBlur.js

function createPayloadImagingGaussianBlurGaussianBlur()

    let code = new Code();

    let bb0 = code.addBlock();

    let bb1 = code.addBlock();

    let bb2 = code.addBlock();

    let bb3 = code.addBlock();

    let bb4 = code.addBlock();

    let bb5 = code.addBlock();

    let bb6 = code.addBlock();

    let bb7 = code.addBlock();

    let bb8 = code.addBlock();

    let bb9 = code.addBlock();

    let bb10 = code.addBlock();

    let bb11 = code.addBlock();

    let bb12 = code.addBlock();

    let bb13 = code.addBlock();

    let bb14 = code.addBlock();

    let bb15 = code.addBlock();

    let bb16 = code.addBlock();

    let bb17 = code.addBlock();

    let bb18 = code.addBlock();

    let bb19 = code.addBlock();

    let bb20 = code.addBlock();

    let bb21 = code.addBlock();

    let bb22 = code.addBlock();

    let bb23 = code.addBlock();

    let bb24 = code.addBlock();

    let bb25 = code.addBlock();

    let bb26 = code.addBlock();

    let bb27 = code.addBlock();

    let bb28 = code.addBlock();

    let bb29 = code.addBlock();

    let bb30 = code.addBlock();

    let bb31 = code.addBlock();

    let bb32 = code.addBlock();

    let bb33 = code.addBlock();

    let bb34 = code.addBlock();

    let bb35 = code.addBlock();

    let bb36 = code.addBlock();

    let slot0 = code.addStackSlot(40, Locked);

    let slot1 = code.addStackSlot(8, Spill);

    let slot2 = code.addStackSlot(8, Spill);

    let slot3 = code.addStackSlot(4, Spill);

    let slot4 = code.addStackSlot(8, Spill);

    let slot5 = code.addStackSlot(8, Spill);

    let slot6 = code.addStackSlot(40, Locked);

    slot6.setOffsetFromFP(-40);

    let tmp141 = code.newTmp(GP);

    let tmp140 = code.newTmp(GP);

    let tmp139 = code.newTmp(GP);

    let tmp138 = code.newTmp(GP);

    let tmp137 = code.newTmp(GP);

    let tmp136 = code.newTmp(GP);

    let tmp135 = code.newTmp(GP);

    let tmp134 = code.newTmp(GP);

    let tmp133 = code.newTmp(GP);

    let tmp132 = code.newTmp(GP);

    let tmp131 = code.newTmp(GP);

    let tmp130 = code.newTmp(GP);

    let tmp129 = code.newTmp(GP);

    let tmp128 = code.newTmp(GP);

    let tmp127 = code.newTmp(GP);

    let tmp126 = code.newTmp(GP);

    let tmp125 = code.newTmp(GP);

    let tmp124 = code.newTmp(GP);

    let tmp123 = code.newTmp(GP);

    let tmp122 = code.newTmp(GP);

    let tmp121 = code.newTmp(GP);

    let tmp120 = code.newTmp(GP);

    let tmp119 = code.newTmp(GP);

    let tmp118 = code.newTmp(GP);

    let tmp117 = code.newTmp(GP);

    let tmp116 = code.newTmp(GP);

    let tmp115 = code.newTmp(GP);

    let tmp114 = code.newTmp(GP);

    let tmp113 = code.newTmp(GP);

    let tmp112 = code.newTmp(GP);

    let tmp111 = code.newTmp(GP);

    let tmp110 = code.newTmp(GP);

    let tmp109 = code.newTmp(GP);

    let tmp108 = code.newTmp(GP);

    let tmp107 = code.newTmp(GP);

    let tmp106 = code.newTmp(GP);

    let tmp105 = code.newTmp(GP);

    let tmp104 = code.newTmp(GP);

    let tmp103 = code.newTmp(GP);

    let tmp102 = code.newTmp(GP);

    let tmp101 = code.newTmp(GP);

    let tmp100 = code.newTmp(GP);

    let tmp99 = code.newTmp(GP);

    let tmp98 = code.newTmp(GP);

    let tmp97 = code.newTmp(GP);

    let tmp96 = code.newTmp(GP);

    let tmp95 = code.newTmp(GP);

    let tmp94 = code.newTmp(GP);

    let tmp93 = code.newTmp(GP);

    let tmp92 = code.newTmp(GP);

    let tmp91 = code.newTmp(GP);

    let tmp90 = code.newTmp(GP);

    let tmp89 = code.newTmp(GP);

    let tmp88 = code.newTmp(GP);

    let tmp87 = code.newTmp(GP);

    let tmp86 = code.newTmp(GP);

    let tmp85 = code.newTmp(GP);

    let tmp84 = code.newTmp(GP);

    let tmp83 = code.newTmp(GP);

    let tmp82 = code.newTmp(GP);

    let tmp81 = code.newTmp(GP);

    let tmp80 = code.newTmp(GP);

    let tmp79 = code.newTmp(GP);

    let tmp78 = code.newTmp(GP);

    let tmp77 = code.newTmp(GP);

    let tmp76 = code.newTmp(GP);

    let tmp75 = code.newTmp(GP);

    let tmp74 = code.newTmp(GP);

    let tmp73 = code.newTmp(GP);

    let tmp72 = code.newTmp(GP);

    let tmp71 = code.newTmp(GP);

    let tmp70 = code.newTmp(GP);

    let tmp69 = code.newTmp(GP);

    let tmp68 = code.newTmp(GP);

    let tmp67 = code.newTmp(GP);

    let tmp66 = code.newTmp(GP);

    let tmp65 = code.newTmp(GP);

    let tmp64 = code.newTmp(GP);

    let tmp63 = code.newTmp(GP);

    let tmp62 = code.newTmp(GP);

    let tmp61 = code.newTmp(GP);

    let tmp60 = code.newTmp(GP);

    let tmp59 = code.newTmp(GP);

    let tmp58 = code.newTmp(GP);

    let tmp57 = code.newTmp(GP);

    let tmp56 = code.newTmp(GP);

    let tmp55 = code.newTmp(GP);

    let tmp54 = code.newTmp(GP);

    let tmp53 = code.newTmp(GP);

    let tmp52 = code.newTmp(GP);

    let tmp51 = code.newTmp(GP);

    let tmp50 = code.newTmp(GP);

    let tmp49 = code.newTmp(GP);

    let tmp48 = code.newTmp(GP);

    let tmp47 = code.newTmp(GP);

    let tmp46 = code.newTmp(GP);

    let tmp45 = code.newTmp(GP);

    let tmp44 = code.newTmp(GP);

    let tmp43 = code.newTmp(GP);

    let tmp42 = code.newTmp(GP);

    let tmp41 = code.newTmp(GP);

    let tmp40 = code.newTmp(GP);

    let tmp39 = code.newTmp(GP);

    let tmp38 = code.newTmp(GP);

    let tmp37 = code.newTmp(GP);

    let tmp36 = code.newTmp(GP);

    let tmp35 = code.newTmp(GP);

    let tmp34 = code.newTmp(GP);

    let tmp33 = code.newTmp(GP);

    let tmp32 = code.newTmp(GP);

    let tmp31 = code.newTmp(GP);

    let tmp30 = code.newTmp(GP);

    let tmp29 = code.newTmp(GP);

    let tmp28 = code.newTmp(GP);

    let tmp27 = code.newTmp(GP);

    let tmp26 = code.newTmp(GP);

    let tmp25 = code.newTmp(GP);

    let tmp24 = code.newTmp(GP);

    let tmp23 = code.newTmp(GP);

    let tmp22 = code.newTmp(GP);

    let tmp21 = code.newTmp(GP);

    let tmp20 = code.newTmp(GP);

    let tmp19 = code.newTmp(GP);

    let tmp18 = code.newTmp(GP);

    let tmp17 = code.newTmp(GP);

    let tmp16 = code.newTmp(GP);

    let tmp15 = code.newTmp(GP);

    let tmp14 = code.newTmp(GP);

    let tmp13 = code.newTmp(GP);

    let tmp12 = code.newTmp(GP);

    let tmp11 = code.newTmp(GP);

    let tmp10 = code.newTmp(GP);

    let tmp9 = code.newTmp(GP);

    let tmp8 = code.newTmp(GP);

    let tmp7 = code.newTmp(GP);

    let tmp6 = code.newTmp(GP);

    let tmp5 = code.newTmp(GP);

    let tmp4 = code.newTmp(GP);

    let tmp3 = code.newTmp(GP);

    let tmp2 = code.newTmp(GP);

    let tmp1 = code.newTmp(GP);

    let tmp0 = code.newTmp(GP);

    let ftmp74 = code.newTmp(FP);

    let ftmp73 = code.newTmp(FP);

    let ftmp72 = code.newTmp(FP);

    let ftmp71 = code.newTmp(FP);

    let ftmp70 = code.newTmp(FP);

    let ftmp69 = code.newTmp(FP);

    let ftmp68 = code.newTmp(FP);

    let ftmp67 = code.newTmp(FP);

    let ftmp66 = code.newTmp(FP);

    let ftmp65 = code.newTmp(FP);

    let ftmp64 = code.newTmp(FP);

    let ftmp63 = code.newTmp(FP);

    let ftmp62 = code.newTmp(FP);

    let ftmp61 = code.newTmp(FP);

    let ftmp60 = code.newTmp(FP);

    let ftmp59 = code.newTmp(FP);

    let ftmp58 = code.newTmp(FP);

    let ftmp57 = code.newTmp(FP);

    let ftmp56 = code.newTmp(FP);

    let ftmp55 = code.newTmp(FP);

    let ftmp54 = code.newTmp(FP);

    let ftmp53 = code.newTmp(FP);

    let ftmp52 = code.newTmp(FP);

    let ftmp51 = code.newTmp(FP);

    let ftmp50 = code.newTmp(FP);

    let ftmp49 = code.newTmp(FP);

    let ftmp48 = code.newTmp(FP);

    let ftmp47 = code.newTmp(FP);

    let ftmp46 = code.newTmp(FP);

    let ftmp45 = code.newTmp(FP);

    let ftmp44 = code.newTmp(FP);

    let ftmp43 = code.newTmp(FP);

    let ftmp42 = code.newTmp(FP);

    let ftmp41 = code.newTmp(FP);

    let ftmp40 = code.newTmp(FP);

    let ftmp39 = code.newTmp(FP);

    let ftmp38 = code.newTmp(FP);

    let ftmp37 = code.newTmp(FP);

    let ftmp36 = code.newTmp(FP);

    let ftmp35 = code.newTmp(FP);

    let ftmp34 = code.newTmp(FP);

    let ftmp33 = code.newTmp(FP);

    let ftmp32 = code.newTmp(FP);

    let ftmp31 = code.newTmp(FP);

    let ftmp30 = code.newTmp(FP);

    let ftmp29 = code.newTmp(FP);

    let ftmp28 = code.newTmp(FP);

    let ftmp27 = code.newTmp(FP);

    let ftmp26 = code.newTmp(FP);

    let ftmp25 = code.newTmp(FP);

    let ftmp24 = code.newTmp(FP);

    let ftmp23 = code.newTmp(FP);

    let ftmp22 = code.newTmp(FP);

    let ftmp21 = code.newTmp(FP);

    let ftmp20 = code.newTmp(FP);

    let ftmp19 = code.newTmp(FP);

    let ftmp18 = code.newTmp(FP);

    let ftmp17 = code.newTmp(FP);

    let ftmp16 = code.newTmp(FP);

    let ftmp15 = code.newTmp(FP);

    let ftmp14 = code.newTmp(FP);

    let ftmp13 = code.newTmp(FP);

    let ftmp12 = code.newTmp(FP);

    let ftmp11 = code.newTmp(FP);

    let ftmp10 = code.newTmp(FP);

    let ftmp9 = code.newTmp(FP);

    let ftmp8 = code.newTmp(FP);

    let ftmp7 = code.newTmp(FP);

    let ftmp6 = code.newTmp(FP);

    let ftmp5 = code.newTmp(FP);

    let ftmp4 = code.newTmp(FP);

    let ftmp3 = code.newTmp(FP);

    let ftmp2 = code.newTmp(FP);

    let ftmp1 = code.newTmp(FP);

    let ftmp0 = code.newTmp(FP);

    let inst;

    let arg;

    bb0.successors.push(new FrequentedBlock(bb2, Normal));

    bb0.successors.push(new FrequentedBlock(bb1, Rare));

    inst = new Inst(Move);

    arg = Arg.createBigImm(144305904, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createAddr(Reg.rbp, 16);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbp);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.extraEarlyClobberedRegs.add(Reg.r11);

    inst.extraClobberedRegs.add(Reg.r11);

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Scratch, type: GP, width: 64});

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547168, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547184, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547192, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547200, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547208, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547216, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547224, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547232, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rax, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(142547240, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rdi, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(0, -65536);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Add64);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(Move64ToDouble);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb0.append(inst);

    inst = new Inst(BranchDouble);

    arg = Arg.createDoubleCond(DoubleEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb0.append(inst);

    bb1.successors.push(new FrequentedBlock(bb2, Normal));

    bb1.predecessors.push(bb0);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb1.append(inst);

    inst = new Inst(ConvertInt32ToDouble);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb1.append(inst);

    inst = new Inst(Jump);

    bb1.append(inst);

    bb2.successors.push(new FrequentedBlock(bb4, Normal));

    bb2.successors.push(new FrequentedBlock(bb3, Rare));

    bb2.predecessors.push(bb0);

    bb2.predecessors.push(bb1);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb2.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb2.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb2.append(inst);

    inst = new Inst(Add64);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb2.append(inst);

    inst = new Inst(Move64ToDouble);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb2.append(inst);

    inst = new Inst(BranchDouble);

    arg = Arg.createDoubleCond(DoubleEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb2.append(inst);

    bb3.successors.push(new FrequentedBlock(bb4, Normal));

    bb3.predecessors.push(bb2);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb3.append(inst);

    inst = new Inst(ConvertInt32ToDouble);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb3.append(inst);

    inst = new Inst(Jump);

    bb3.append(inst);

    bb4.successors.push(new FrequentedBlock(bb6, Normal));

    bb4.successors.push(new FrequentedBlock(bb5, Rare));

    bb4.predecessors.push(bb2);

    bb4.predecessors.push(bb3);

    inst = new Inst(Add64);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb4.append(inst);

    inst = new Inst(Move64ToDouble);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb4.append(inst);

    inst = new Inst(BranchDouble);

    arg = Arg.createDoubleCond(DoubleEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb4.append(inst);

    bb5.successors.push(new FrequentedBlock(bb6, Normal));

    bb5.predecessors.push(bb4);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb5.append(inst);

    inst = new Inst(ConvertInt32ToDouble);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb5.append(inst);

    inst = new Inst(Jump);

    bb5.append(inst);

    bb6.successors.push(new FrequentedBlock(bb8, Normal));

    bb6.successors.push(new FrequentedBlock(bb7, Rare));

    bb6.predecessors.push(bb4);

    bb6.predecessors.push(bb5);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb6.append(inst);

    inst = new Inst(Add64);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb6.append(inst);

    inst = new Inst(Move64ToDouble);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb6.append(inst);

    inst = new Inst(BranchDouble);

    arg = Arg.createDoubleCond(DoubleEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb6.append(inst);

    bb7.successors.push(new FrequentedBlock(bb8, Normal));

    bb7.predecessors.push(bb6);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb7.append(inst);

    inst = new Inst(ConvertInt32ToDouble);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb7.append(inst);

    inst = new Inst(Jump);

    bb7.append(inst);

    bb8.successors.push(new FrequentedBlock(bb10, Normal));

    bb8.successors.push(new FrequentedBlock(bb9, Rare));

    bb8.predecessors.push(bb6);

    bb8.predecessors.push(bb7);

    inst = new Inst(Move);

    arg = Arg.createBigImm(117076488, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb8.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.r8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    bb8.append(inst);

    inst = new Inst(Add64);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb8.append(inst);

    inst = new Inst(Move64ToDouble);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    bb8.append(inst);

    inst = new Inst(BranchDouble);

    arg = Arg.createDoubleCond(DoubleEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    bb8.append(inst);

    bb9.successors.push(new FrequentedBlock(bb10, Normal));

    bb9.predecessors.push(bb8);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(Below);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb9.append(inst);

    inst = new Inst(ConvertInt32ToDouble);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    bb9.append(inst);

    inst = new Inst(Jump);

    bb9.append(inst);

    bb10.successors.push(new FrequentedBlock(bb18, Normal));

    bb10.predecessors.push(bb8);

    bb10.predecessors.push(bb9);

    inst = new Inst(Move);

    arg = Arg.createBigImm(144506584, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rdi, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r9);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createAddr(Reg.r9, -8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(144506544, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(NotEqual);

    inst.args.push(arg);

    arg = Arg.createAddr(Reg.rdi, 0);

    inst.args.push(arg);

    arg = Arg.createImm(80);

    inst.args.push(arg);

    arg = Arg.createBigImm(144506544, 1);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(144506552, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rdi, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot2, 0);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createAddr(Reg.rdi, -8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot3, 0);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(MoveZeroToDouble);

    arg = Arg.createTmp(Reg.xmm7);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createImm(10);

    inst.args.push(arg);

    arg = Arg.createStack(slot4, 0);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Move);

    arg = Arg.createBigImm(2, -65536);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    bb10.append(inst);

    inst = new Inst(Jump);

    bb10.append(inst);

    bb11.successors.push(new FrequentedBlock(bb13, Normal));

    bb11.predecessors.push(bb35);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    bb11.append(inst);

    inst = new Inst(Move);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    bb11.append(inst);

    inst = new Inst(Jump);

    bb11.append(inst);

    bb12.successors.push(new FrequentedBlock(bb13, Normal));

    bb12.predecessors.push(bb34);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    bb12.append(inst);

    inst = new Inst(Jump);

    bb12.append(inst);

    bb13.successors.push(new FrequentedBlock(bb15, Normal));

    bb13.predecessors.push(bb11);

    bb13.predecessors.push(bb12);

    inst = new Inst(Move);

    arg = Arg.createImm(-6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb13.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm7);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb13.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm7);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb13.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm7);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb13.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm7);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb13.append(inst);

    inst = new Inst(Jump);

    bb13.append(inst);

    bb14.successors.push(new FrequentedBlock(bb15, Normal));

    bb14.predecessors.push(bb31);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb14.append(inst);

    inst = new Inst(Jump);

    bb14.append(inst);

    bb15.successors.push(new FrequentedBlock(bb28, Normal));

    bb15.successors.push(new FrequentedBlock(bb16, Normal));

    bb15.predecessors.push(bb13);

    bb15.predecessors.push(bb14);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb15.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    bb15.append(inst);

    bb16.successors.push(new FrequentedBlock(bb29, Normal));

    bb16.successors.push(new FrequentedBlock(bb17, Normal));

    bb16.predecessors.push(bb15);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(GreaterThanOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(267);

    inst.args.push(arg);

    bb16.append(inst);

    bb17.successors.push(new FrequentedBlock(bb18, Normal));

    bb17.predecessors.push(bb16);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb17.append(inst);

    inst = new Inst(Move);

    arg = Arg.createImm(-6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    bb17.append(inst);

    inst = new Inst(Jump);

    bb17.append(inst);

    bb18.successors.push(new FrequentedBlock(bb20, Normal));

    bb18.successors.push(new FrequentedBlock(bb19, Rare));

    bb18.predecessors.push(bb10);

    bb18.predecessors.push(bb17);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    bb18.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb18.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(400);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb18.append(inst);

    inst = new Inst(BranchTest32);

    arg = Arg.createResCond(NonZero);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    bb18.append(inst);

    bb19.successors.push(new FrequentedBlock(bb20, Normal));

    bb19.predecessors.push(bb18);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb19.append(inst);

    inst = new Inst(Jump);

    bb19.append(inst);

    bb20.successors.push(new FrequentedBlock(bb22, Normal));

    bb20.predecessors.push(bb18);

    bb20.predecessors.push(bb19);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Rshift32);

    arg = Arg.createImm(31);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Xor32);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb20.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot3, 0);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb20.append(inst);

    inst = new Inst(Move);

    arg = Arg.createStack(slot2, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Move);

    arg = Arg.createIndex(Reg.rsi, Reg.rdi, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Move);

    arg = Arg.createImm(10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(MoveConditionallyTest64);

    arg = Arg.createResCond(NonZero);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(-1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(NonZero);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r10);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb20.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(NotEqual);

    inst.args.push(arg);

    arg = Arg.createAddr(Reg.rdi, 0);

    inst.args.push(arg);

    arg = Arg.createImm(79);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb20.append(inst);

    inst = new Inst(Move);

    arg = Arg.createAddr(Reg.rdi, 8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r12);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createAddr(Reg.r12, -8);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r13);

    inst.args.push(arg);

    bb20.append(inst);

    inst = new Inst(Jump);

    bb20.append(inst);

    bb21.successors.push(new FrequentedBlock(bb22, Normal));

    bb21.predecessors.push(bb27);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    bb21.append(inst);

    inst = new Inst(Jump);

    bb21.append(inst);

    bb22.successors.push(new FrequentedBlock(bb25, Normal));

    bb22.successors.push(new FrequentedBlock(bb23, Normal));

    bb22.predecessors.push(bb20);

    bb22.predecessors.push(bb21);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb22.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    bb22.append(inst);

    bb23.successors.push(new FrequentedBlock(bb26, Normal));

    bb23.successors.push(new FrequentedBlock(bb24, Normal));

    bb23.predecessors.push(bb22);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(GreaterThanOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(400);

    inst.args.push(arg);

    bb23.append(inst);

    bb24.successors.push(new FrequentedBlock(bb27, Normal));

    bb24.predecessors.push(bb23);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createImm(4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r14);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r14);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createIndex(Reg.r9, Reg.r15, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Rshift32);

    arg = Arg.createImm(31);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Xor32);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r13);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rbx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    bb24.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createIndex(Reg.r12, Reg.rbx, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(MulDouble);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(AddDouble);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(MulDouble);

    arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(AddDouble);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r15);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(MulDouble);

    arg = Arg.createIndex(Reg.r9, Reg.r15, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(AddDouble);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(MulDouble);

    arg = Arg.createIndex(Reg.r9, Reg.r14, 8, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(AddDouble);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb24.append(inst);

    inst = new Inst(Jump);

    bb24.append(inst);

    bb25.successors.push(new FrequentedBlock(bb27, Normal));

    bb25.predecessors.push(bb22);

    inst = new Inst(Jump);

    bb25.append(inst);

    bb26.successors.push(new FrequentedBlock(bb27, Normal));

    bb26.predecessors.push(bb23);

    inst = new Inst(Jump);

    bb26.append(inst);

    bb27.successors.push(new FrequentedBlock(bb21, Normal));

    bb27.successors.push(new FrequentedBlock(bb30, Normal));

    bb27.predecessors.push(bb24);

    bb27.predecessors.push(bb26);

    bb27.predecessors.push(bb25);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb27.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb27.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(7);

    inst.args.push(arg);

    bb27.append(inst);

    bb28.successors.push(new FrequentedBlock(bb31, Normal));

    bb28.predecessors.push(bb15);

    inst = new Inst(Jump);

    bb28.append(inst);

    bb29.successors.push(new FrequentedBlock(bb31, Normal));

    bb29.predecessors.push(bb16);

    inst = new Inst(Jump);

    bb29.append(inst);

    bb30.successors.push(new FrequentedBlock(bb31, Normal));

    bb30.predecessors.push(bb27);

    inst = new Inst(Move);

    arg = Arg.createStack(slot1, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    bb30.append(inst);

    inst = new Inst(Jump);

    bb30.append(inst);

    bb31.successors.push(new FrequentedBlock(bb14, Normal));

    bb31.successors.push(new FrequentedBlock(bb32, Normal));

    bb31.predecessors.push(bb30);

    bb31.predecessors.push(bb29);

    bb31.predecessors.push(bb28);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb31.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb31.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createImm(7);

    inst.args.push(arg);

    bb31.append(inst);

    bb32.successors.push(new FrequentedBlock(bb34, Normal));

    bb32.successors.push(new FrequentedBlock(bb33, Rare));

    bb32.predecessors.push(bb31);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createImm(400);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    bb32.append(inst);

    inst = new Inst(BranchTest32);

    arg = Arg.createResCond(NonZero);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb32.append(inst);

    bb33.successors.push(new FrequentedBlock(bb34, Normal));

    bb33.predecessors.push(bb32);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createImm(0);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb33.append(inst);

    inst = new Inst(Jump);

    bb33.append(inst);

    bb34.successors.push(new FrequentedBlock(bb12, Normal));

    bb34.successors.push(new FrequentedBlock(bb35, Normal));

    bb34.predecessors.push(bb32);

    bb34.predecessors.push(bb33);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createImm(4);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb34.append(inst);

    inst = new Inst(DivDouble);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm1);

    inst.args.push(arg);

    arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb34.append(inst);

    inst = new Inst(DivDouble);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r11);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createRelCond(AboveOrEqual);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.r8);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm2);

    inst.args.push(arg);

    arg = Arg.createIndex(Reg.r9, Reg.rdi, 8, 0);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Add32);

    arg = Arg.createImm(2);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(DivDouble);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rsi);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm3);

    inst.args.push(arg);

    arg = Arg.createIndex(Reg.r9, Reg.rsi, 8, 0);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(DivDouble);

    arg = Arg.createTmp(Reg.xmm6);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createDoubleCond(DoubleNotEqualOrUnordered);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.ColdUse, type: FP, width: 64});

    bb34.append(inst);

    inst = new Inst(MoveDouble);

    arg = Arg.createTmp(Reg.xmm5);

    inst.args.push(arg);

    arg = Arg.createIndex(Reg.r9, Reg.rax, 8, 0);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Move32);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb34.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rdx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb34.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createImm(400);

    inst.args.push(arg);

    bb34.append(inst);

    bb35.successors.push(new FrequentedBlock(bb11, Normal));

    bb35.successors.push(new FrequentedBlock(bb36, Normal));

    bb35.predecessors.push(bb34);

    inst = new Inst(Move);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb35.append(inst);

    inst = new Inst(Patch);

    arg = Arg.createSpecial();

    inst.args.push(arg);

    arg = Arg.createResCond(Overflow);

    inst.args.push(arg);

    arg = Arg.createImm(1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createStack(slot5, 0);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rcx);

    inst.args.push(arg);

    inst.patchHasNonArgEffects = true;

    inst.extraEarlyClobberedRegs = new Set();

    inst.extraClobberedRegs = new Set();

    inst.patchArgData = [];

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.Use, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.UseZDef, type: GP, width: 32});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 64});

    inst.patchArgData.push({role: Arg.LateColdUse, type: GP, width: 32});

    bb35.append(inst);

    inst = new Inst(Branch32);

    arg = Arg.createRelCond(LessThan);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    arg = Arg.createImm(267);

    inst.args.push(arg);

    bb35.append(inst);

    bb36.predecessors.push(bb35);

    inst = new Inst(Move);

    arg = Arg.createBigImm(144506576, 1);

    inst.args.push(arg);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb36.append(inst);

    inst = new Inst(Ret64);

    arg = Arg.createTmp(Reg.rax);

    inst.args.push(arg);

    bb36.append(inst);

    return code;

Source code

Revision control

Copy as Markdown

Other Tools