LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: saeefahmad[P]MIPS-pipeline-simulator/instruction.cpp
// Function: Instruction::Instruction(Instruction&)
Instruction::Instruction(Instruction& inst) {
  init(inst.type, inst.arg1, inst.arg2, inst.arg3, inst.immidiate, inst.address);
  A = inst.A;
  B = inst.B;
  cond = inst.cond;
  decodeCycle = inst.decodeCycle;
  aluOut = inst.aluOut;
  loadMemData = inst.loadMemData;
  fetchedAtCycle = inst.fetchedAtCycle;
  srcCycle1 = inst.srcCycle1;
  srcCycle2 = inst.srcCycle2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, (%rsp)
callq 0x83f0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movb 0x34(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x34(%rax)
movq -0x10(%rbp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/instruction.cpp
// Function: Instruction::operator=(Instruction&)
Instruction& Instruction::operator=(Instruction& rhs) {
  if (this == &rhs)
    return *this;
  init(rhs.type, rhs.arg1, rhs.arg2, rhs.arg3, rhs.immidiate, rhs.address);
  A = rhs.A;
  B = rhs.B;
  cond = rhs.cond;
  decodeCycle = rhs.decodeCycle;
  aluOut = rhs.aluOut;
  loadMemData = rhs.loadMemData;
  fetchedAtCycle = rhs.fetchedAtCycle;
  srcCycle1 = rhs.srcCycle1;
  srcCycle2 = rhs.srcCycle2;
  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x86cb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8767
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x18(%rbp), %rax
movl 0x10(%rax), %r9d
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, (%rsp)
callq 0x83f0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rcx
movb 0x34(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x34(%rax)
movq -0x18(%rbp), %rcx
movl 0x38(%rcx), %ecx
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq -0x18(%rbp), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, 0x30(%rax)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_montecarlo_option_pricing_model.cpp
// Function: normal_distribution<double>::normal_distribution()
normal_distribution()
   : exprtk::ifunction<T>(2)
   {
      std::random_device device;
      std::array<unsigned int,std::mt19937::state_size> seed;
      std::generate_n(seed.data(), seed.size(), std::ref(device));
      std::seed_seq seq(std::begin(seed), std::end(seed));
      generator.seed(seq);
   }

// Assembly:
subq $0x1db8, %rsp           # imm = 0x1DB8
movq %rdi, 0x1db0(%rsp)
movq 0x1db0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq $0x2, 0x1da8(%rsp)
leaq 0x1da8(%rsp), %rsi
callq 0x11b050
movq 0x28(%rsp), %rdi
leaq 0x4a1257(%rip), %rax    # 0x5ba778
movq %rax, (%rdi)
addq $0x28, %rdi
callq 0x11b0a0
jmp 0x11952f
leaq 0xa10(%rsp), %rdi
callq 0x11b0c0
jmp 0x11953e
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b1d0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x11b1e0
movq %rax, 0x20(%rsp)
leaq 0xa10(%rsp), %rdi
callq 0x11b1f0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdx
callq 0x11b160
jmp 0x119589
leaq 0x50(%rsp), %rdi
callq 0x11b220
movq %rax, 0x8(%rsp)
jmp 0x11959a
leaq 0x50(%rsp), %rdi
callq 0x11b230
movq %rax, (%rsp)
jmp 0x1195aa
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x11b240
jmp 0x1195bf
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
leaq 0x30(%rsp), %rsi
callq 0x11b320
jmp 0x1195d4
leaq 0x30(%rsp), %rdi
callq 0x11b4a0
leaq 0xa10(%rsp), %rdi
callq 0x11b4b0
addq $0x1db8, %rsp           # imm = 0x1DB8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1da0(%rsp)
movl %eax, 0x1d9c(%rsp)
jmp 0x11964a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1da0(%rsp)
movl %eax, 0x1d9c(%rsp)
jmp 0x11963d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1da0(%rsp)
movl %eax, 0x1d9c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b4a0
leaq 0xa10(%rsp), %rdi
callq 0x11b4b0
movq 0x28(%rsp), %rdi
callq 0x11bc10
movq 0x1da0(%rsp), %rdi
callq 0x111470
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: FR13ndSDP[P]NHT/main.cpp
// Function: initialize(int, double, double, double, double, double, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
int initialize(int N, double L, double Tw, double TA, double A1, double K, Vec &T, Vec &position)
{
    for (int i=0; i<N; i++)
    {
        position[i] = L/(2*N)+L/N*i;
        T[i] = Tw-A1*(TA-Tw)/K*position[i];
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2671
movsd -0x10(%rbp), %xmm1
movl -0x4(%rbp), %eax
shll %eax
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x4(%rbp), %xmm2
divsd %xmm2, %xmm0
cvtsi2sdl -0x44(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3490
movsd -0x68(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x40(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3490
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movsd (%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x44(%rbp), %rsi
callq 0x3490
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x2593
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: FR13ndSDP[P]NHT/Parameters.cpp
// Function: Parameters::Parameters()
Parameters::Parameters()
{
    uS = 1;
    B_L = 3;
    B_R = 3;
    Q_L = 0;
    Q_R = 0;
    L = 0.3;
    N = 64;
    dt = 60;
    A1 = 6;
    A2 = 35;
    RHOC = 1.05e6;
    K = 0.85;
    TA = 20;
    TB = -10;
    solver = "TDMA";
    P = 1e-6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x68, %rdi
movq %rdi, -0x20(%rbp)
callq 0x22a0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movl $0x1, 0x4(%rax)
movl $0x3, 0x8(%rax)
movl $0x3, 0xc(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movabsq $0x3fd3333333333333, %rcx # imm = 0x3FD3333333333333
movq %rcx, 0x18(%rax)
movl $0x40, (%rax)
movabsq $0x404e000000000000, %rcx # imm = 0x404E000000000000
movq %rcx, 0x10(%rax)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, 0x20(%rax)
movabsq $0x4041800000000000, %rcx # imm = 0x4041800000000000
movq %rcx, 0x28(%rax)
movabsq $0x4130059000000000, %rcx # imm = 0x4130059000000000
movq %rcx, 0x30(%rax)
movabsq $0x3feb333333333333, %rcx # imm = 0x3FEB333333333333
movq %rcx, 0x38(%rax)
movabsq $0x4034000000000000, %rcx # imm = 0x4034000000000000
movq %rcx, 0x40(%rax)
movabsq $-0x3fdc000000000000, %rcx # imm = 0xC024000000000000
movq %rcx, 0x48(%rax)
leaq 0x3be5(%rip), %rsi      # 0x80e0
callq 0x2290
jmp 0x4502
movq -0x28(%rbp), %rax
movsd 0x3bca(%rip), %xmm0     # 0x80d8
movsd %xmm0, 0x50(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2120
movq -0x10(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: FR13ndSDP[P]NHT/Parameters.cpp
// Function: Parameters::outputFile(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
int Parameters::outputFile(Vec vec_1, Vec vec_2)
{
    ofstream outfile;
    outfile.open("temperature.dat");
//    outfile << "Title = \"The temperature distribution\"" << endl;
//    outfile << "Variables = \"x/m\", \"T/'C\""<<endl;
    for (int i=0; i< vec_1.size(); i++)
    {
        outfile << vec_1[i] << " " << vec_2[i] << endl;
    }
    outfile.close();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rsi, -0x240(%rbp)
movq %rdx, -0x238(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0x2330
movq -0x230(%rbp), %rdi
leaq 0x3335(%rip), %rsi      # 0x815b
movl $0x10, %edx
callq 0x2040
jmp 0x4e32
movl $0x0, -0x228(%rbp)
movq -0x240(%rbp), %rdi
movslq -0x228(%rbp), %rax
movq %rax, -0x248(%rbp)
callq 0x3e40
movq %rax, %rcx
movq -0x248(%rbp), %rax
cmpq %rcx, %rax
jae 0x4f28
movq -0x240(%rbp), %rdi
movslq -0x228(%rbp), %rsi
callq 0x3490
movsd (%rax), %xmm0
leaq -0x218(%rbp), %rdi
callq 0x2390
movq %rax, -0x250(%rbp)
jmp 0x4e95
movq -0x250(%rbp), %rdi
leaq 0x32b6(%rip), %rsi      # 0x8159
callq 0x21f0
movq %rax, -0x258(%rbp)
jmp 0x4eb1
movq -0x238(%rbp), %rdi
movslq -0x228(%rbp), %rsi
callq 0x3490
movq -0x258(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2390
movq %rax, -0x260(%rbp)
jmp 0x4edd
movq -0x260(%rbp), %rdi
movq 0x60c5(%rip), %rsi      # 0xafb0
callq 0x2220
jmp 0x4ef2
jmp 0x4ef4
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x4e3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x22d0
jmp 0x4f4d
leaq -0x218(%rbp), %rdi
callq 0x22b0
jmp 0x4f36
leaq -0x218(%rbp), %rdi
callq 0x22d0
xorl %eax, %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: FR13ndSDP[P]NHT/Solver.cpp
// Function: maxabs(std::vector<double, std::allocator<double>>)
double maxabs(Vec v)
{
    double min = *min_element(v.begin(),v.end());
    double max = *max_element(v.begin(),v.end()); 
    if (abs(max) > abs(min))
        return abs(max);
    else
        return abs(min);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x71a0
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x71d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x7160
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7200
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x71a0
movq -0x60(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x71d0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x7220
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7200
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x7260
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x7260
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5afe
movsd -0x38(%rbp), %xmm0
callq 0x7260
movsd %xmm0, -0x8(%rbp)
jmp 0x5b0d
movsd -0x18(%rbp), %xmm0
callq 0x7260
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::CRSmatrix(std::vector<double, std::allocator<double>>, std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
CRSmatrix::CRSmatrix(std::vector<double> v, std::vector<int> r, std::vector<int> c) {
    value = v;
    rowPtr = r;
    colInd = c;

    //find total number of rows
    rowNum = rowPtr.size() - 1;

    //find total number of columns
    colNum = 0;
    for (unsigned int i = 0; i < colInd.size(); i++) {
        if (colInd[i] > colNum) {
            colNum = colInd[i];
        }
    }
    colNum++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x38(%rbp)
movq %rdx, -0x68(%rbp)
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x41a0
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x58(%rbp)
callq 0x41c0
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
callq 0x41c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x41e0
jmp 0x25da
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x4430
jmp 0x25ed
movq -0x60(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x4430
jmp 0x2600
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x4680
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq $0x1, %rcx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, -0x30(%rbp)
movq -0x50(%rbp), %rdi
movl -0x30(%rbp), %eax
movq %rax, -0x70(%rbp)
addq $0x38, %rdi
callq 0x4680
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x26be
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movq -0x50(%rbp), %rcx
movl (%rax), %eax
cmpl 0x4(%rcx), %eax
jle 0x26ae
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
jmp 0x26ae
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x46c0
movq -0x58(%rbp), %rdi
callq 0x46c0
movq -0x40(%rbp), %rdi
callq 0x4720
jmp 0x26d1
jmp 0x26b0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x2628
movq -0x50(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::retrieveElement(unsigned int, unsigned int)
double CRSmatrix::retrieveElement(unsigned int i, unsigned int j) {
    int pos = rowPtr[i];
    bool found = 0;
    for (int n = rowPtr[i]; n < rowPtr[i] + (rowPtr[i + 1] - rowPtr[i]); n++) {
        if (colInd[n] == j) {
            pos = n;
            found = 1;
        }
    }
    if (found) return value[pos];
    return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x38(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x46a0
movq -0x30(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
movq %rax, %rsi
movl -0x34(%rbp), %eax
subl (%rsi), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x2df9
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movslq -0x24(%rbp), %rsi
callq 0x46a0
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x2de9
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x1, -0x1d(%rbp)
jmp 0x2deb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d68
testb $0x1, -0x1d(%rbp)
je 0x2e1b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x4950
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2e23
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::changeValue(double, unsigned int, unsigned int)
void CRSmatrix::changeValue(double x, unsigned int i, unsigned int j) {
    if (value.empty()) {
        value.push_back(x);
        colInd.push_back(j);
        rowPtr.push_back(0);
        rowPtr.push_back(1);
    } else {
        value.push_back(x);
        colInd.push_back(j);
        if (rowPtr.size() <= i + 1)
            rowPtr.push_back(value.size());
        else
            rowPtr[rowPtr.size() - 1] = rowPtr[rowPtr.size() - 1] + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
callq 0x4970
testb $0x1, %al
jne 0x2e5e
jmp 0x2ebb
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4830
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x49b0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movl $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x49b0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movl $0x1, -0x24(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x49b0
jmp 0x2f86
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4830
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x49b0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
callq 0x4680
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
ja 0x2f27
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x49e0
movq -0x40(%rbp), %rdi
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x49b0
jmp 0x2f84
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
addq $0x20, %rdi
callq 0x4680
movq -0x58(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x46a0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x4680
movq -0x50(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x46a0
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x2f86
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::productAx(std::vector<double, std::allocator<double>>)
std::vector<double> CRSmatrix::productAx(std::vector<double> x) {
    std::vector<double> product(x.size());
    for (int i = 0; i < rowNum; i++) {
        for (int j = 0; j < colNum; j++) {
            product[i] += x[j] * retrieveElement(i, j);
        }
    }
    return product;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x49e0
movq %rax, -0x48(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4a00
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x4a20
jmp 0x2ff2
leaq -0x1a(%rbp), %rdi
callq 0x4a90
movl $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl (%rcx), %eax
jge 0x30a7
movl $0x0, -0x34(%rbp)
movq -0x58(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x3097
movq -0x68(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x4950
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movl -0x30(%rbp), %esi
movl -0x34(%rbp), %edx
callq 0x2d20
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x70(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x4950
movsd -0x78(%rbp), %xmm0
movsd -0x70(%rbp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x4a90
jmp 0x30c7
jmp 0x3099
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x3002
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x30ba
movq -0x50(%rbp), %rdi
callq 0x4720
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2310
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::deleteValue(unsigned int, unsigned int)
void CRSmatrix::deleteValue(unsigned int i, unsigned int j) {
    for (int n = rowPtr[i]; n < rowPtr[i] + (rowPtr[i + 1] - rowPtr[i]); n++) {
        if (colInd[n] == j) {
            value.erase(value.begin() + n);
            colInd.erase(colInd.begin() + n);
            for (unsigned int m = i + 1; m < rowPtr.size(); m++) rowPtr[m]--;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x68(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x70(%rbp)
addq $0x20, %rdi
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x46a0
movq -0x68(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x74(%rbp)
addq $0x20, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movl -0x74(%rbp), %edx
movl -0x70(%rbp), %ecx
movq %rax, %rsi
movl -0x6c(%rbp), %eax
subl (%rsi), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x3280
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x46a0
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x3270
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
addq $0x8, %rdi
callq 0x4b20
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4b50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4b90
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4ab0
movq -0x68(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x80(%rbp)
addq $0x38, %rdi
callq 0x4c40
movq %rax, -0x50(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4c70
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4cb0
movq -0x80(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4bd0
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %eax
movq %rax, -0x90(%rbp)
addq $0x20, %rdi
callq 0x4680
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jae 0x326e
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movl -0x5c(%rbp), %eax
movl %eax, %esi
callq 0x46a0
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x3224
jmp 0x3270
jmp 0x3272
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3100
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::printA()
void CRSmatrix::printA() {
    for (int valI = 0; valI < rowNum; valI++) {
        for (int valJ = 0; valJ < colNum; valJ++) {
            std::cout << " " << retrieveElement(valI, valJ);
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3321
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x3303
movq 0xdd00(%rip), %rdi      # 0x10fd0
leaq 0x8e73(%rip), %rsi      # 0xc14a
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x2d20
movq -0x20(%rbp), %rdi
callq 0x2350
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x32bd
movq 0xdcc6(%rip), %rdi      # 0x10fd0
movq 0xdca7(%rip), %rsi      # 0x10fb8
callq 0x21a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x32ab
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: vectorNorm(std::vector<double, std::allocator<double>>)
double vectorNorm(std::vector<double> x) {
    double sum = 0.0;
    for (unsigned int i = 0; i < x.size(); i++) {
        sum += pow(x[i], 2);
    }
    return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x28(%rbp)
callq 0x49e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x339f
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x4950
movsd (%rax), %xmm0
movsd 0x8c83(%rip), %xmm1     # 0xc008
callq 0x2300
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x334f
movsd -0x10(%rbp), %xmm0
callq 0x2120
addq $0x30, %rsp
popq %rbp
retq
nop
// File: fanyazhi[P]Spline-Fitting/src/cubicSpline.cpp
// Function: constructVariables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<double> constructVariables(string address) {
    //initiate vector x to store all elements in file
    vector<double> x;

    ifstream inValue;
    inValue.open(address);

    //check if file is open, if not exit code
    if (!inValue.is_open()) {
        cout << "error: file did not open" << endl;
        exit(1);
    }

    // Declare a variable to load the contents from the file
    string line = "";

    // Loading the value vector
    while (inValue >> line) {
        double value = stod(line);
        x.push_back(value);
    }

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, -0x278(%rbp)
movq %rdi, -0x270(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x41a0
leaq -0x220(%rbp), %rdi
callq 0x2200
jmp 0x9ec2
movq -0x278(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x2150
jmp 0x9edc
leaq -0x220(%rbp), %rdi
callq 0x22c0
movb %al, -0x279(%rbp)
jmp 0x9ef0
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x9f65
jmp 0x9efc
movq 0x70cd(%rip), %rdi      # 0x10fd0
leaq 0x21e6(%rip), %rsi      # 0xc0f0
callq 0x2170
movq %rax, -0x288(%rbp)
jmp 0x9f18
movq -0x288(%rbp), %rdi
movq 0x7092(%rip), %rsi      # 0x10fb8
callq 0x21a0
jmp 0x9f2d
movl $0x1, %edi
callq 0x2210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0xa0bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0xa091
leaq -0x251(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x2320
movq -0x290(%rbp), %rdx
leaq 0x22cf(%rip), %rsi      # 0xc255
leaq -0x250(%rbp), %rdi
callq 0x4780
jmp 0x9f94
leaq -0x251(%rbp), %rdi
callq 0x21c0
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2250
movq %rax, -0x298(%rbp)
jmp 0x9fbc
movq -0x298(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2240
movb %al, -0x299(%rbp)
jmp 0x9fda
movb -0x299(%rbp), %al
testb $0x1, %al
jne 0x9fe9
jmp 0xa06d
xorl %eax, %eax
movl %eax, %esi
leaq -0x250(%rbp), %rdi
callq 0xa130
movsd %xmm0, -0x2a8(%rbp)
jmp 0xa003
movq -0x270(%rbp), %rdi
movsd -0x2a8(%rbp), %xmm0
movsd %xmm0, -0x260(%rbp)
leaq -0x260(%rbp), %rsi
callq 0x4830
jmp 0xa028
jmp 0x9fa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x251(%rbp), %rdi
callq 0x21c0
jmp 0xa091
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x20e0
jmp 0xa091
movb $0x1, -0x11(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x20e0
leaq -0x220(%rbp), %rdi
callq 0x2050
testb $0x1, -0x11(%rbp)
jne 0xa0ab
jmp 0xa09f
leaq -0x220(%rbp), %rdi
callq 0x2050
jmp 0xa0bb
movq -0x270(%rbp), %rdi
callq 0x4720
movq -0x268(%rbp), %rax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x270(%rbp), %rdi
callq 0x4720
movq -0x228(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>> const&)
basic_node(const basic_node& o, const allocator_type& al)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x20(%rdi)
addq $0x24, %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1331b0
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x7, %rax
ja 0xf2c36
movq -0x30(%rbp), %rax
leaq 0x1580b9(%rip), %rcx    # 0x24ac50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c810
jmp 0xf2baf
jmp 0xf2c36
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xf0f50
jmp 0xf2c3c
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c840
jmp 0xf2bda
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c870
jmp 0xf2beb
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c8a0
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c8d0
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c900
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c930
jmp 0xf2c36
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13c960
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::swap(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>&)
void swap(basic_node& o) {
                using st = void (*)(basic_node& , basic_node&);
                static constexpr st swap[8][8] = {
#                   define S(...) value::swap<basic_node, __VA_ARGS__>
                        {S(object, object), S(object, array), S(object, string), S(object, real), S(object, sint), S(object, uint), S(object,  boolean), S(object,  null)},
                        {          nullptr, S(array,  array), S(array,  string), S(array,  real), S(array,  sint), S(array,  uint), S(array,   boolean), S(array,   null)},
                        {          nullptr,          nullptr, S(string, string), S(string, real), S(string, sint), S(string, uint), S(string,  boolean), S(string,  null)},
                        {          nullptr,          nullptr,           nullptr, S(real,   real), S(real,   sint), S(real,   uint), S(real,    boolean), S(real,    null)},
                        {          nullptr,          nullptr,           nullptr,         nullptr, S(sint,   sint), S(sint,   uint), S(sint,    boolean), S(sint,    null)},
                        {          nullptr,          nullptr,           nullptr,         nullptr,         nullptr, S(uint,   uint), S(uint,    boolean), S(uint,    null)},
                        {          nullptr,          nullptr,           nullptr,         nullptr,         nullptr,         nullptr, S(boolean, boolean), S(boolean, null)},
                        {          nullptr,          nullptr,           nullptr,         nullptr,         nullptr,         nullptr,             nullptr, S(null,    null)}
#                   undef S
                };
                kind_ < o.kind_ ?
                    swap[(int)kind_][(int)o.kind_](*this, o) :
                    swap[(int)o.kind_][(int)kind_](o, *this)
                ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xf3bce
movq -0x18(%rbp), %rdi
movslq 0x20(%rdi), %rcx
leaq 0x24ce2d(%rip), %rax    # 0x3409e0
shlq $0x6, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq 0x20(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0xf3bf6
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rcx
leaq 0x24cdff(%rip), %rax    # 0x3409e0
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x20(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::hash<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>>::operator()(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&) const
std::size_t operator ()(const json::basic_node<Tr>& n) const noexcept {
                switch (n.kind()) {
#                   define CXON_JSON_TYPE_DEF(T)        case json::node_kind::T: return make_hash(json::get<typename json::basic_node<Tr>::T>(n))
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
                return 0; // LCOV_EXCL_LINE
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf1bf0
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x7, %eax
ja 0x17222a
movq -0x20(%rbp), %rax
leaq 0xdcf8d(%rip), %rcx     # 0x24f0f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x172260
movq %rax, %rdi
callq 0x172240
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x1722a0
movq %rax, %rdi
callq 0x172280
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x1722e0
movq %rax, %rdi
callq 0x1722c0
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x172320
movq %rax, %rdi
callq 0x172300
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x172360
movq %rax, %rdi
callq 0x172340
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x1723a0
movq %rax, %rdi
callq 0x172380
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x1723e0
movq %rax, %rdi
callq 0x1723c0
movq %rax, -0x8(%rbp)
jmp 0x172232
movq -0x18(%rbp), %rdi
callq 0x172420
movq %rax, %rdi
callq 0x172400
movq %rax, -0x8(%rbp)
jmp 0x172232
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: oknenavin[P]cxon/test/src/json/json.node-time.native.cxx
// Function: test::kind::time_cxon_native(test::test&)
void time_cxon_native(test& t) {
        auto i = native::executors_.find(t.source.substr(t.source.rfind('/') + 1));
        i != native::executors_.end() ?
            i->second(t) :
            (time_cxon_node(t), t.flag = true, void())
        ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
movq %rdx, -0x60(%rbp)
callq 0xf2e0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rcx
movq %rax, %rdx
incq %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xf630
movq -0x58(%rbp), %rsi
leaq 0x183ed1(%rip), %rdi    # 0x344800
callq 0x1c7f50
movq %rax, -0x50(%rbp)
jmp 0x1c093a
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf490
leaq 0x183eae(%rip), %rdi    # 0x344800
callq 0x1c7fb0
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c7f80
testb $0x1, %al
jne 0x1c096e
jmp 0x1c0983
leaq -0x10(%rbp), %rdi
callq 0x1c7fe0
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
jmp 0x1c0994
movq -0x8(%rbp), %rdi
callq 0x2418c0
movq -0x8(%rbp), %rax
movb $0x1, 0x78(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf490
movq -0x38(%rbp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: lemire[P]runningmaxmin/unit.cpp
// Function: compare(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
bool compare(std::vector<floattype> & a, std::vector<floattype> & b) {
    if (a.size() != b.size())
        return false;
    for (uint k = 0; k < a.size(); ++k)
        if (a[k] != b[k])
            return false;
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3410
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x3410
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x22fb
movb $0x0, 0x37(%rsp)
jmp 0x2376
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3410
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2371
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x3430
vmovsd (%rax), %xmm0
vmovsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x3430
vmovsd (%rsp), %xmm0
vucomisd (%rax), %xmm0
jne 0x235b
jp 0x235b
jmp 0x2362
movb $0x0, 0x37(%rsp)
jmp 0x2376
jmp 0x2364
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2303
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lemire[P]runningmaxmin/./runningmaxmin.h
// Function: lemiremaxmintruestreaming::update(double)
void update(floattype value) {
        if (nonempty(&up) != 0) {
            if (value > tailvalue(&up)) {
                prunetail(&up);
                while (((nonempty(&up)) != 0) && (value >= tailvalue(&up))) {
                    prunetail(&up);
                }
            } else {
                prunetail(&lo);
                while (((nonempty(&lo)) != 0) && (value <= tailvalue(&lo))) {
                    prunetail(&lo);
                }
            }
        }
        push(&up, n, value);
        if (n == ww + headindex(&up)) {
            prunehead(&up);
        }

        push(&lo, n, value);
        if (n == ww + headindex(&lo)) {
            prunehead(&lo);
        }
        n++;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
vmovsd %xmm0, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x92d0
cmpl $0x0, %eax
je 0x90c3
movq 0x40(%rsp), %rdi
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, 0x38(%rsp)
callq 0x92f0
vmovaps %xmm0, %xmm1
vmovsd 0x38(%rsp), %xmm0
vucomisd %xmm1, %xmm0
jbe 0x9051
movq 0x40(%rsp), %rdi
callq 0x9320
movq 0x40(%rsp), %rdi
callq 0x92d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x37(%rsp)
je 0x9039
movq 0x40(%rsp), %rdi
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, 0x28(%rsp)
callq 0x92f0
vmovaps %xmm0, %xmm1
vmovsd 0x28(%rsp), %xmm0
vucomisd %xmm1, %xmm0
setae %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x9043
jmp 0x904f
movq 0x40(%rsp), %rdi
callq 0x9320
jmp 0x8ff7
jmp 0x90c1
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x9320
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x92d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x27(%rsp)
je 0x90a5
movq 0x40(%rsp), %rdi
vmovsd 0x48(%rsp), %xmm0
vmovsd %xmm0, 0x18(%rsp)
addq $0x18, %rdi
callq 0x92f0
vmovsd 0x18(%rsp), %xmm1
vucomisd %xmm1, %xmm0
setae %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x90af
jmp 0x90bf
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x9320
jmp 0x905f
jmp 0x90c1
jmp 0x90c3
movq 0x40(%rsp), %rdi
movl 0x30(%rdi), %esi
vmovsd 0x48(%rsp), %xmm0
callq 0x9350
movq 0x40(%rsp), %rdi
movl 0x30(%rdi), %eax
movl %eax, 0x14(%rsp)
movl 0x34(%rdi), %eax
movl %eax, 0x10(%rsp)
callq 0x93c0
movl 0x10(%rsp), %ecx
movl %eax, %edx
movl 0x14(%rsp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jne 0x9108
movq 0x40(%rsp), %rdi
callq 0x93e0
movq 0x40(%rsp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movl 0x30(%rax), %esi
vmovsd 0x48(%rsp), %xmm0
callq 0x9350
movq 0x40(%rsp), %rdi
movl 0x30(%rdi), %eax
movl %eax, 0xc(%rsp)
movl 0x34(%rdi), %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x93c0
movl 0x8(%rsp), %ecx
movl %eax, %edx
movl 0xc(%rsp), %eax
addl %edx, %ecx
cmpl %ecx, %eax
jne 0x915c
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x93e0
movq 0x40(%rsp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
addq $0x58, %rsp
retq
nop
// File: lemire[P]runningmaxmin/./deque.h
// Function: init(intfloatqueue*, unsigned int)
inline void init(intfloatqueue * q, uint size) {
    size = nextPowerOfTwo(size + 1);
    q->nodes =
        reinterpret_cast<intfloatnode *>(malloc(sizeof(intfloatnode) * size));
    q->head = 0;
    q->tail = 0;
    q->mask = size - 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %edi
addl $0x1, %edi
callq 0x92a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %edi
shlq $0x4, %rdi
callq 0x2110
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0xc(%rax)
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: lemire[P]runningmaxmin/./deque.h
// Function: nextPowerOfTwo(unsigned int)
inline uint nextPowerOfTwo(uint x) {
    uint result = 1;
    while (result < x) {
        result <<= 1;
    }
    return result;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x1, -0x8(%rsp)
movl -0x8(%rsp), %eax
cmpl -0x4(%rsp), %eax
jae 0x92c2
movl -0x8(%rsp), %eax
shll %eax
movl %eax, -0x8(%rsp)
jmp 0x92ac
movl -0x8(%rsp), %eax
retq
nopw (%rax,%rax)
// File: lemire[P]runningmaxmin/./mono_wedge.h
// Function: void mono_wedge::mono_wedge_update<std::deque<Sample, std::allocator<Sample>>, Sample, std::greater<Sample>>(std::deque<Sample, std::allocator<Sample>>&, Sample const&, std::greater<Sample>)
void mono_wedge_update(
		Wedge   &wedge,
		const T &value,
		Compare  comp)
	{
		wedge.erase(
			mono_wedge_search(wedge.begin(), wedge.end(), value, comp),
			wedge.end());
		wedge.push_back(value);
	}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, (%rsp)
movq 0xf8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xae80
movq 0xf8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xaeb0
movq 0xf0(%rsp), %rcx
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0xad10
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xaee0
movq 0xf8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0xaeb0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xaee0
movq (%rsp), %rsi
leaq 0x8(%rsp), %rdi
leaq 0xd0(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0xac80
movq 0xf8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0xaf30
addq $0x108, %rsp            # imm = 0x108
retq
nopw (%rax,%rax)
// File: lemire[P]runningmaxmin/./mono_wedge.h
// Function: std::_Deque_iterator<Sample, Sample&, Sample*> mono_wedge::mono_wedge_search<std::_Deque_iterator<Sample, Sample&, Sample*>, Sample, std::greater<Sample>>(std::_Deque_iterator<Sample, Sample&, Sample*>, std::_Deque_iterator<Sample, Sample&, Sample*>, Sample const&, std::greater<Sample>)
Iterator mono_wedge_search(
		Iterator begin,
		Iterator end,
		const T &value,
		Compare  comp)
	{
		long size = long(end - begin);
		if (size <= 0) return end;

		// Linear search through at most J elements, J = log2(N-J).
		long i = 1;
		for (; ((size-i) >> i) > 0; ++i)
		{
			// If you get a compile error here, your Wedge type does not
			//   support random-access iterators and should be changed!
			Iterator test = end-i;
			if (comp(*test, value)) return test+1;
		}

		// Defer to lower_bound for binary search.
		return std::lower_bound<Iterator, T, Compare>(begin, end-(i-1), value, comp);
	}

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rax, %rdx
movq %rdx, 0x20(%rsp)
movq %rax, 0xc0(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
callq 0xb3a0
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
jg 0xad82
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0xb310
jmp 0xae65
movq $0x1, 0x90(%rsp)
movq 0x98(%rsp), %rax
subq 0x90(%rsp), %rax
movq 0x90(%rsp), %rcx
sarq %cl, %rax
cmpq $0x0, %rax
jle 0xae1f
movq 0x10(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0xb7a0
leaq 0x70(%rsp), %rdi
callq 0xc680
movq %rax, %rsi
movq 0xa0(%rsp), %rdx
leaq 0xbf(%rsp), %rdi
callq 0xc650
testb $0x1, %al
jne 0xadee
jmp 0xae04
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl $0x1, %edx
callq 0xb5e0
jmp 0xae65
jmp 0xae06
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0xad8e
movq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0xb310
movq 0x10(%rsp), %rsi
movq 0x90(%rsp), %rdx
subq $0x1, %rdx
leaq 0x30(%rsp), %rdi
callq 0xb7a0
movq 0x18(%rsp), %rdi
movq 0xa0(%rsp), %rcx
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xc690
movq 0x20(%rsp), %rax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: nmmmnu[P]HM3/common/stringtokenizer.cc
// Function: StringTokenizer::getNext()
StringRef StringTokenizer::getNext(){
	size_t start = pos_;

	while(hasNext() && line_[pos_] != delimiter_)
		++pos_;

	size_t size = pos_ - start;

	StringRef s{ &line_[start], size };

	while(hasNext() && line_[pos_] == delimiter_)
		++pos_;

	return s;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1ff0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x1e24
jmp 0x1e4d
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq (%rax), %rsi
callq 0x2030
movq 0x8(%rsp), %rcx
movsbl (%rax), %eax
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x1e57
jmp 0x1e68
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1e0b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0x2030
movq %rax, %rsi
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x1ac0
movq 0x8(%rsp), %rdi
callq 0x1ff0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x1eb3
jmp 0x1edc
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq (%rax), %rsi
callq 0x2030
movq 0x8(%rsp), %rcx
movsbl (%rax), %eax
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x1ee6
jmp 0x1ef7
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1e9a
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)