LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mateuz[P]MTS-LS1/source/F2.cpp
// Function: F2::compute(double*)
double F2::compute(double* x){
  int    i;
  double result;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = 0; i < dimension; i++) {
    anotherz[i] = x[i] - Ovector[i];
  }
  
  // // T_{osz}
  // transform_osz(anotherz, dimension);
  
  // // T_{asy}^{0.2}
  // transform_asy(anotherz, 0.2);

  // // lambda
  // Lambda(anotherz, 10);

  result = rastrigin(anotherz,dimension);
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0xa473
movq -0x28(%rbp), %rdi
callq 0x3e10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0xa4bf
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa47a
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rsi
movl 0xb8(%rdi), %edx
callq 0x6350
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F3.cpp
// Function: F3::F3()
F3::F3():Benchmarks(){
  Ovector = NULL;
  minX = -32;
  maxX = 32;
  ID = 3;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xf6a4(%rip), %rcx      # 0x19bb8
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffffe0, 0xb0(%rax) # imm = 0xFFFFFFE0
movl $0x20, 0xb4(%rax)
movl $0x3, 0x8(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xa562
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopw %cs:(%rax,%rax)
// File: mateuz[P]MTS-LS1/source/F3.cpp
// Function: F3::compute(double*)
double F3::compute(double*x){
  int    i;
  double result;

  if(Ovector == NULL) {
    // Ovector = createShiftVector(dimension,minX,maxX);
    Ovector = readOvector();
  }

  for(i = dimension - 1; i >= 0; i--) {
    anotherz[i] = x[i] - Ovector[i];
  }
  
  result = ackley(anotherz,dimension);

  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0xa673
movq -0x28(%rbp), %rdi
callq 0x3e10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movl 0xb8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xa6bf
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa683
movq -0x28(%rbp), %rdi
movq 0x70(%rdi), %rsi
movl 0xb8(%rdi), %edx
callq 0x65b0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F4.cpp
// Function: F4::F4()
F4::F4():Benchmarks(){
	Ovector = NULL;
	minX = -100;
	maxX = 100;
	ID = 4;
        s_size = 7;
	// lookup2 = lookupprepare(nonSeparableGroupSize);
	// lookup = lookupprepare(dimension - nonSeparableGroupSize);
        anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xf4ec(%rip), %rcx      # 0x19c00
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0x4, 0x8(%rax)
movl $0x7, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xa769
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F5.cpp
// Function: F5::F5()
F5::F5():Benchmarks(){
  Ovector = NULL;
  minX = -5;
  maxX = 5;
  ID = 5;
  s_size = 7;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xf004(%rip), %rcx      # 0x19c48
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xfffffffb, 0xb0(%rax) # imm = 0xFFFFFFFB
movl $0x5, 0xb4(%rax)
movl $0x5, 0x8(%rax)
movl $0x7, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xac99
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F6.cpp
// Function: F6::F6()
F6::F6():Benchmarks(){
  Ovector = NULL;
  minX = -32;
  maxX = 32;
  ID = 6;
  s_size = 7;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xeb1c(%rip), %rcx      # 0x19c90
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffffe0, 0xb0(%rax) # imm = 0xFFFFFFE0
movl $0x20, 0xb4(%rax)
movl $0x6, 0x8(%rax)
movl $0x7, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xb1c9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F7.cpp
// Function: F7::F7()
F7::F7():Benchmarks(){
	Ovector = NULL;
	minX = -100;
	maxX = 100;
	ID = 7;
        s_size = 7;
        anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xe634(%rip), %rcx      # 0x19cd8
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0x7, 0x8(%rax)
movl $0x7, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xb6f9
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F7.cpp
// Function: F7::~F7()
F7::~F7(){
	delete[] Ovector;
	delete[] Pvector;
        delete[] anotherz;        for (int i = 0; i < 25; ++i)
          {
            delete[] r25[i];
          }
        for (int i = 0; i < 50; ++i)
          {
            delete[] r50[i];
          }
        for (int i = 0; i < 100; ++i)
          {
            delete[] r100[i];
          }
        delete[] r25;
        delete[] r50;
        delete[] r100;
        delete[] s;
        delete[] w;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xe57a(%rip), %rcx      # 0x19cc8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xb76c
movq -0x20(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb787
movq -0x30(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xb7a2
movq -0x38(%rbp), %rdi
callq 0x3230
movl $0x0, -0xc(%rbp)
cmpl $0x19, -0xc(%rbp)
jge 0xb7e2
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xb7d5
movq -0x40(%rbp), %rdi
callq 0x3230
jmp 0xb7d7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb7a9
movl $0x0, -0x10(%rbp)
cmpl $0x32, -0x10(%rbp)
jge 0xb822
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xb815
movq -0x48(%rbp), %rdi
callq 0x3230
jmp 0xb817
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb7e9
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0xb862
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xb855
movq -0x50(%rbp), %rdi
callq 0x3230
jmp 0xb857
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb829
movq -0x28(%rbp), %rax
movq 0xd8(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xb880
movq -0x58(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe0(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xb89e
movq -0x60(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xe8(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xb8bc
movq -0x68(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0xb8da
movq -0x70(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0xb8f8
movq -0x78(%rbp), %rdi
callq 0x3230
movq -0x28(%rbp), %rdi
callq 0x3a10
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mateuz[P]MTS-LS1/source/F8.cpp
// Function: F8::F8()
F8::F8():Benchmarks(){
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 8;
  s_size = 20;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xe14c(%rip), %rcx      # 0x19d20
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0x8, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xbc29
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F8.cpp
// Function: F8::compute(double*)
double F8::compute(double* x){
  int    i;
  double result=0.0;

  if(Ovector == NULL) {
    Ovector = readOvector();
    Pvector = readPermVector();
    r25 = readR(25);
    r50 = readR(50);
    r100 = readR(100);
    s = readS(s_size);
    w = readW(s_size);
  }

  for(i = 0; i < dimension; i++) {
    anotherz[i] = x[i] - Ovector[i];
  }
  
  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * elliptic(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }
  
  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0xbf21
movq -0x30(%rbp), %rdi
callq 0x3e10
movq -0x30(%rbp), %rdi
movq %rax, 0x48(%rdi)
callq 0x4ad0
movq -0x30(%rbp), %rdi
movq %rax, 0x58(%rdi)
movl $0x19, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xd8(%rdi)
movl $0x32, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe0(%rdi)
movl $0x64, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe8(%rdi)
movl 0x3c(%rdi), %esi
callq 0x5640
movq -0x30(%rbp), %rdi
movq %rax, 0xf0(%rdi)
movl 0x3c(%rdi), %esi
callq 0x58e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0xbf6d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbf28
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0xc014
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x5b80
movq -0x30(%rbp), %rdi
movq %rax, 0x78(%rdi)
movq 0xf8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rdi), %rsi
movq 0xf0(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x6290
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc004
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0xc006
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbf7b
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mateuz[P]MTS-LS1/source/F9.cpp
// Function: F9::F9()
F9::F9():Benchmarks(){
  Ovector = NULL;
  minX = -100;
  maxX = 100;
  ID = 9;
  s_size = 20;
  anotherz = new double[dimension];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x28(%rbp), %rax
leaq 0xdd24(%rip), %rcx      # 0x19d68
movq %rcx, (%rax)
movq $0x0, 0x48(%rax)
movl $0xffffff9c, 0xb0(%rax) # imm = 0xFFFFFF9C
movl $0x64, 0xb4(%rax)
movl $0x9, 0x8(%rax)
movl $0x14, 0x3c(%rax)
movslq 0xb8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x3030
movq %rax, -0x20(%rbp)
jmp 0xc099
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x70(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3a10
movq -0x10(%rbp), %rdi
callq 0x3320
nopl (%rax)
// File: mateuz[P]MTS-LS1/source/F9.cpp
// Function: F9::compute(double*)
double F9::compute(double*x){
  // int k, i;
  int i;
  double result=0.0;

  if(Ovector==NULL){
    Ovector = readOvector();
    Pvector = readPermVector();
    r25 = readR(25);
    r50 = readR(50);
    r100 = readR(100);
    s = readS(s_size);
    w = readW(s_size);
  }

  for( i=0;i<dimension;i++){
    anotherz[i]=x[i]-Ovector[i];
  }
  
  // s_size non-separable part with rotation
  int c = 0;
  for (i = 0; i < s_size; i++)
    {
      // cout<<"c="<<c<<", i="<<i<<endl;
      anotherz1 = rotateVector(i, c);
      // cout<<"done rot"<<endl;
      result += w[i] * rastrigin(anotherz1, s[i]);
      delete []anotherz1;
      // cout<<result<<endl;
    }


  return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, 0x48(%rax)
jne 0xc391
movq -0x30(%rbp), %rdi
callq 0x3e10
movq -0x30(%rbp), %rdi
movq %rax, 0x48(%rdi)
callq 0x4ad0
movq -0x30(%rbp), %rdi
movq %rax, 0x58(%rdi)
movl $0x19, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xd8(%rdi)
movl $0x32, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe0(%rdi)
movl $0x64, %esi
callq 0x51e0
movq -0x30(%rbp), %rdi
movq %rax, 0xe8(%rdi)
movl 0x3c(%rdi), %esi
callq 0x5640
movq -0x30(%rbp), %rdi
movq %rax, 0xf0(%rdi)
movl 0x3c(%rdi), %esi
callq 0x58e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0xf8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0xb8(%rcx), %eax
jge 0xc3dd
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x48(%rax), %rcx
movslq -0x14(%rbp), %rdx
subsd (%rcx,%rdx,8), %xmm0
movq 0x70(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc398
movl $0x0, -0x24(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x3c(%rcx), %eax
jge 0xc484
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x5b80
movq -0x30(%rbp), %rdi
movq %rax, 0x78(%rdi)
movq 0xf8(%rdi), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movq 0x78(%rdi), %rsi
movq 0xf0(%rdi), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x6350
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc474
movq -0x38(%rbp), %rdi
callq 0x3230
jmp 0xc476
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc3eb
movsd -0x20(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: superyuan[P]refeditor/DiploidConstructor.cpp
// Function: parseParameters(int, char**)
static bool parseParameters (int argc, char *argv[])
{
	int c;
	while ((c = getopt (argc, argv, "r:g:o:l:d:s:")) != -1) {
		switch(c) {
			case 'r':
				strcpy(inputReferenceGenomeFileName, optarg);
				break;
			case 'g':
				strcpy(genotypesFileName, optarg);
				break;
			case 'o':
				strcpy(outputReferenceGenomeFileName, optarg);
				strcpy(dipmapFileName, optarg);
				strcat(dipmapFileName, ".dipmap");
				break;
			case 'l':
				readLength=atoi(optarg);
				break;
			case 'd':
				maxDeletion=atoi(optarg);
				break;
			case 's':
				gender=*optarg;
				break;
			case '?':
				return false;
				break;
		}
	}  
	if (strlen(inputReferenceGenomeFileName)==0 || strlen(genotypesFileName)==0 || strlen(outputReferenceGenomeFileName)==0 || readLength==0)
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x7932(%rip), %rdx      # 0xc35f
callq 0x30a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x4b2b
movl -0x14(%rbp), %eax
addl $-0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x34, %eax
ja 0x4b26
movq -0x20(%rbp), %rax
leaq 0x75a6(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xd542(%rip), %rax      # 0x11fb0
movq (%rax), %rsi
leaq 0xd858(%rip), %rdi      # 0x122d0
callq 0x3230
jmp 0x4b26
movq 0xd527(%rip), %rax      # 0x11fb0
movq (%rax), %rsi
leaq 0xdb3d(%rip), %rdi      # 0x125d0
callq 0x3230
jmp 0x4b26
movq 0xd50c(%rip), %rax      # 0x11fb0
movq (%rax), %rsi
leaq 0xd922(%rip), %rdi      # 0x123d0
callq 0x3230
movq 0xd4f6(%rip), %rax      # 0x11fb0
movq (%rax), %rsi
leaq 0xda0c(%rip), %rdi      # 0x124d0
callq 0x3230
leaq 0xda00(%rip), %rdi      # 0x124d0
leaq 0x7895(%rip), %rsi      # 0xc36c
callq 0x3470
jmp 0x4b26
movq 0xd4cb(%rip), %rax      # 0x11fb0
movq (%rax), %rdi
callq 0x33e0
movl %eax, 0xdbdd(%rip)      # 0x126d0
jmp 0x4b26
movq 0xd4b4(%rip), %rax      # 0x11fb0
movq (%rax), %rdi
callq 0x33e0
movl %eax, 0xdbca(%rip)      # 0x126d4
jmp 0x4b26
movq 0xd49d(%rip), %rax      # 0x11fb0
movq (%rax), %rax
movb (%rax), %al
movb %al, 0xd77a(%rip)       # 0x12298
jmp 0x4b26
movb $0x0, -0x1(%rbp)
jmp 0x4b74
jmp 0x4a1f
leaq 0xd79e(%rip), %rdi      # 0x122d0
callq 0x3120
cmpq $0x0, %rax
je 0x4b6a
leaq 0xda8c(%rip), %rdi      # 0x125d0
callq 0x3120
cmpq $0x0, %rax
je 0x4b6a
leaq 0xd87a(%rip), %rdi      # 0x123d0
callq 0x3120
cmpq $0x0, %rax
je 0x4b6a
cmpl $0x0, 0xdb68(%rip)      # 0x126d0
jne 0x4b70
movb $0x0, -0x1(%rbp)
jmp 0x4b74
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: superyuan[P]refeditor/DiploidConstructor.cpp
// Function: printHaploid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static int printHaploid(string chrName)
{
	static string newLine = "";
	assert(chrName[chrName.length()-1] != 'b');
	string value = chrMap[chrName];
	outputReferenceGenomeFile << newLine << ">" << chrName;
	newLine = "\n";
	for (int i=0, length=value.length(); i<length; i++) {
		if (i%LINE_LENGTH == 0)
			outputReferenceGenomeFile << newLine;
		outputReferenceGenomeFile << value[i];
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
cmpb $0x0, 0xd5e1(%rip)      # 0x12b48
jne 0x55cf
leaq 0xd5d8(%rip), %rdi      # 0x12b48
callq 0x3490
cmpl $0x0, %eax
je 0x55cf
leaq -0x9(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3460
movq -0x58(%rbp), %rdx
leaq 0xd596(%rip), %rdi      # 0x12b28
leaq 0x6d95(%rip), %rsi      # 0xc32e
callq 0x5810
jmp 0x55a0
leaq -0x9(%rbp), %rdi
callq 0x32d0
movq 0xca08(%rip), %rdi      # 0x11fb8
leaq 0xd571(%rip), %rsi      # 0x12b28
leaq 0xccd2(%rip), %rdx      # 0x12290
callq 0x3210
leaq 0xd57e(%rip), %rdi      # 0x12b48
callq 0x3170
movq -0x50(%rbp), %rdi
callq 0x33c0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x34f0
movsbl (%rax), %eax
cmpl $0x62, %eax
je 0x55f2
jmp 0x5637
leaq 0x6df6(%rip), %rdi      # 0xc3ef
leaq 0x6d9b(%rip), %rsi      # 0xc39b
movl $0x4b, %edx
leaq 0x6e06(%rip), %rcx      # 0xc412
callq 0x3180
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x32d0
leaq 0xd51b(%rip), %rdi      # 0x12b48
callq 0x3160
jmp 0x5745
movq -0x50(%rbp), %rsi
leaq 0xd49e(%rip), %rdi      # 0x12ae0
callq 0x5970
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3110
leaq 0xd27e(%rip), %rdi      # 0x128d8
leaq 0xd4c7(%rip), %rsi      # 0x12b28
callq 0x3220
movq %rax, -0x60(%rbp)
jmp 0x566c
movq -0x60(%rbp), %rdi
leaq 0x6db4(%rip), %rsi      # 0xc42b
callq 0x3250
movq %rax, -0x68(%rbp)
jmp 0x5682
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x3220
jmp 0x5691
leaq 0xd490(%rip), %rdi      # 0x12b28
leaq 0x6d8e(%rip), %rsi      # 0xc42d
callq 0x3370
jmp 0x56a6
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x33c0
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x5734
movl -0x44(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x56ff
leaq 0xd200(%rip), %rdi      # 0x128d8
leaq 0xd449(%rip), %rsi      # 0x12b28
callq 0x3220
jmp 0x56e6
jmp 0x56ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3518
jmp 0x5745
movslq -0x44(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x34f0
movq %rax, -0x70(%rbp)
jmp 0x5712
movq -0x70(%rbp), %rax
movsbl (%rax), %esi
leaq 0xd1b8(%rip), %rdi      # 0x128d8
callq 0x3300
jmp 0x5727
jmp 0x5729
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x56b9
leaq -0x40(%rbp), %rdi
callq 0x3518
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3450
nop
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: CLineFields::divide(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int CLineFields::divide(string s, string divisor, vector<string> &field)
{
	field.clear();
	size_t found;
	int start = 0;
	found = s.find(divisor);
	while (found != string::npos){
		field.push_back(s.substr(start,found-start));
		start = found+divisor.length();
		found = s.find(divisor,start);
	}
	field.push_back(s.substr(start,s.length()-start));
	return field.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9a30
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl $0x0, -0x2c(%rbp)
xorl %eax, %eax
movl %eax, %edx
callq 0x3500
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x906b
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
movslq -0x2c(%rbp), %rdx
movq -0x28(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3280
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x60d0
jmp 0x9001
leaq -0x50(%rbp), %rdi
callq 0x3518
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x33c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rcx
movq -0xa8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rdx
callq 0x3500
movq %rax, -0x28(%rbp)
jmp 0x8fb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3518
jmp 0x90fa
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x33c0
movq -0x90(%rbp), %rsi
movq -0xc0(%rbp), %rdx
movq %rax, %rcx
movslq -0x2c(%rbp), %rax
subq %rax, %rcx
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3280
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x60d0
jmp 0x90ca
leaq -0x80(%rbp), %rdi
callq 0x3518
movq -0x20(%rbp), %rdi
callq 0x5ac0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3518
movq -0x58(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: CLineFields::readline(bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CLineFields::readline (bool ignoreComment, string divisor)
{
	field.clear();
	do {
		getline(*fp, line);
		if (line.length()==0)
			return false;
	} while ((line[0]=='@' || line[0]=='#') &&(ignoreComment)) ;

	divide(line, divisor, field);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x80(%rbp)
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x9a30
movq -0x78(%rbp), %rsi
movq 0x18(%rsi), %rdi
addq $0x20, %rsi
callq 0x3080
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
callq 0x33c0
cmpq $0x0, %rax
jne 0x9319
movb $0x0, -0x1(%rbp)
jmp 0x93e4
jmp 0x931b
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34f0
movsbl (%rax), %eax
cmpl $0x40, %eax
je 0x9355
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x34f0
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x23, %ecx
movb %al, -0x81(%rbp)
jne 0x935e
movb -0x11(%rbp), %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x92ec
movq -0x78(%rbp), %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3110
movq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3110
jmp 0x9388
movq -0x78(%rbp), %rcx
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rcx, %rdi
callq 0x8f60
jmp 0x939e
leaq -0x60(%rbp), %rdi
callq 0x3518
leaq -0x40(%rbp), %rdi
callq 0x3518
movb $0x1, -0x1(%rbp)
jmp 0x93e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x93d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3518
leaq -0x40(%rbp), %rdi
callq 0x3518
jmp 0x93f2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3450
nopl (%rax,%rax)
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: substr2int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int&)
int substr2int(string &s, int &p)
{
	//''' convert substring of s started from p to an interger '''
	//''' return the value and the position of last digit + 1 '''
	int sum = 0;
	char c = s[p];

	while (c>='0' && c<='9') {
		sum = sum*10 + c-'0';
		p ++;
		c = s[p];
	}
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x34f0
movb (%rax), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x16(%rbp)
jl 0x9447
movsbl -0x15(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x9450
jmp 0x9482
imull $0xa, -0x14(%rbp), %eax
movsbl -0x15(%rbp), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq (%rax), %rsi
callq 0x34f0
movb (%rax), %al
movb %al, -0x15(%rbp)
jmp 0x942c
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: pileupShortStr2Info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int>>>&)
void pileupShortStr2Info(string &s, map<char,int> &pileupInfo)
{
	int i = 0;
	initPileupInfo(pileupInfo);
	if (s=="NoInfo")
		return;
	while (i<(int)s.length()) {
		int num = substr2int(s, i);
		pileupInfo[s[i]] = num;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9490
movq -0x8(%rbp), %rdi
leaq 0x2f51(%rip), %rsi      # 0xc45c
callq 0x89a0
testb $0x1, %al
jne 0x9516
jmp 0x9518
jmp 0x957a
jmp 0x951a
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33c0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x957a
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x9400
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x34f0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x9a50
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x951a
addq $0x30, %rsp
popq %rbp
retq
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: pileupInfoMajor(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int>>>&, float)
char pileupInfoMajor(map<char,int> &pileupInfo, float threadhold)
{
	int total = 0;
	for (int i=0; i<(int)sizeof(keys); i++) {
		if (keys[i]=='N')
			continue; // we don't count 'N' into total
		total += pileupInfo[keys[i]];
	}
	if (total > 0) {
		for (int i=0; i<(int)sizeof(keys); i++) {
			if (keys[i]=='N')
				continue; // we don't count 'N' as majority
			if (((float)pileupInfo[keys[i]])/(float)total>=threadhold)  { //must be >= than threadhold(eg. 80%)
				return keys[i];
			}
		}
	}
	return (char)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x95e5
movslq -0x1c(%rbp), %rcx
leaq 0x8cf8(%rip), %rax      # 0x122a8
movsbl (%rax,%rcx), %eax
cmpl $0x4e, %eax
jne 0x95bb
jmp 0x95da
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0x8cde(%rip), %rsi      # 0x122a8
addq %rax, %rsi
callq 0x9a50
movl (%rax), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x959f
cmpl $0x0, -0x18(%rbp)
jle 0x965a
movl $0x0, -0x20(%rbp)
cmpl $0x5, -0x20(%rbp)
jge 0x9658
movslq -0x20(%rbp), %rcx
leaq 0x8ca5(%rip), %rax      # 0x122a8
movsbl (%rax,%rcx), %eax
cmpl $0x4e, %eax
jne 0x960e
jmp 0x964d
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rax
leaq 0x8c8b(%rip), %rsi      # 0x122a8
addq %rax, %rsi
callq 0x9a50
cvtsi2ssl (%rax), %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
divss %xmm1, %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x964b
movslq -0x20(%rbp), %rcx
leaq 0x8c65(%rip), %rax      # 0x122a8
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x965e
jmp 0x964d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x95f2
jmp 0x965a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: superyuan[P]refeditor/CLineFields1.cpp
// Function: pileupLongStr2ShortStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
string pileupLongStr2ShortStr(string &s, char base)
{
	stringstream ss;
	map<char,int> pileupInfo;
	pileupLongStr2Info(s, base, pileupInfo);
	for (int i=0; i<(int)sizeof(keys); i++) {
		if (pileupInfo[keys[i]]>0)
			ss << pileupInfo[keys[i]] << keys[i];
	}
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x1f8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31b0
leaq -0x1d0(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x9c10
movq -0x1e8(%rbp), %rdx
movq -0x10(%rbp), %rdi
movsbl -0x11(%rbp), %esi
callq 0x9670
jmp 0x989e
movl $0x0, -0x1e0(%rbp)
cmpl $0x5, -0x1e0(%rbp)
jge 0x99a1
movslq -0x1e0(%rbp), %rax
leaq 0x89e5(%rip), %rsi      # 0x122a8
addq %rax, %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x9a50
movq %rax, -0x200(%rbp)
jmp 0x98db
movq -0x200(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x998b
leaq -0x190(%rbp), %rax
movq %rax, -0x210(%rbp)
movslq -0x1e0(%rbp), %rax
leaq 0x89a1(%rip), %rsi      # 0x122a8
addq %rax, %rsi
leaq -0x1d0(%rbp), %rdi
callq 0x9a50
movq %rax, -0x208(%rbp)
jmp 0x991f
movq -0x210(%rbp), %rdi
movq -0x208(%rbp), %rax
movl (%rax), %esi
callq 0x3440
movq %rax, -0x218(%rbp)
jmp 0x993d
movq -0x218(%rbp), %rdi
movslq -0x1e0(%rbp), %rax
leaq 0x8956(%rip), %rcx      # 0x122a8
movsbl (%rax,%rcx), %esi
callq 0x3300
jmp 0x995d
jmp 0x998b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x9c30
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x99de
jmp 0x998d
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0x98a8
movq -0x1f8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3240
jmp 0x99b6
leaq -0x1d0(%rbp), %rdi
callq 0x9c30
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movq -0x1f0(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1d8(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch_v2.cpp
// Function: main
int main()
{
	test_tuple();
	test_array();
	test_queue();
	test_deque();
	test_list();
	test_vector();
	test_set();
	test_unordered_set();
	test_dict();
	test_unordered_dict();

	return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x4b230
callq 0x4b8d0
callq 0x4c2b0
callq 0x4c5f0
callq 0x4c930
callq 0x4cc70
callq 0x4cfb0
callq 0x4d2f0
callq 0x4d630
callq 0x4d970
xorl %eax, %eax
popq %rcx
retq
nop
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch_v2.cpp
// Function: void test_array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 3ul>(std::shared_ptr<swxJson::Json>, char const*, char const*, bool)
void test_array(JsonPtr json, const char* key, const char* desc, bool compatibleMode)
{
	cout<<endl<<desc<<endl;

	std::array<K, N> elemArray = json->wantArray<K, N>(key, compatibleMode);
	for (auto& element: elemArray)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x28(%rsp)
movb %cl, %al
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
andb $0x1, %al
movb %al, 0x12f(%rsp)
movq 0x49af2(%rip), %rdi     # 0x97fd8
movq 0x49ac3(%rip), %rsi     # 0x97fb0
movq %rsi, 0x20(%rsp)
callq 0x4a360
movq %rax, %rdi
movq 0x130(%rsp), %rsi
callq 0x4a300
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4a360
movq 0x28(%rsp), %rdi
callq 0x4ddf0
movq %rax, 0x30(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x4a530
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x4dcf0
jmp 0x4e55b
movb 0x12f(%rsp), %al
movb %al, 0x17(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4a530
movq 0x18(%rsp), %rdx
leaq 0x33bc3(%rip), %rsi     # 0x82144
leaq 0x70(%rsp), %rdi
callq 0x4dcf0
jmp 0x4e58d
movq 0x30(%rsp), %rsi
movb 0x17(%rsp), %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
leaq 0x70(%rsp), %r8
callq 0x54dd0
jmp 0x4e5b8
leaq 0x70(%rsp), %rdi
callq 0x4a5b8
leaq 0x6f(%rsp), %rdi
callq 0x4a390
leaq 0xa8(%rsp), %rdi
callq 0x4a5b8
leaq 0xa7(%rsp), %rdi
callq 0x4a390
leaq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x54f60
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x54f70
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x4e711
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x499a6(%rip), %rdi     # 0x97fd8
leaq 0x33ff6(%rip), %rsi     # 0x8262f
callq 0x4a300
movq %rax, 0x8(%rsp)
jmp 0x4e645
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4a2c0
movq %rax, (%rsp)
jmp 0x4e65a
movq (%rsp), %rdi
movq 0x4994b(%rip), %rsi     # 0x97fb0
callq 0x4a360
jmp 0x4e66c
jmp 0x4e66e
movq 0x58(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x58(%rsp)
jmp 0x4e611
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4e6df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4e6c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4a5b8
leaq 0x6f(%rsp), %rdi
callq 0x4a390
leaq 0xa8(%rsp), %rdi
callq 0x4a5b8
leaq 0xa7(%rsp), %rdi
callq 0x4a390
jmp 0x4e726
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x54f90
jmp 0x4e726
leaq 0xc8(%rsp), %rdi
callq 0x54f90
addq $0x148, %rsp            # imm = 0x148
retq
movq 0x98(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch_v2.cpp
// Function: void test_queue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_queue(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::queue<K> elemQueue = json->wantQueue<K>(key);
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop();
	}
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x48c1d(%rip), %rdi     # 0x97fd8
movq 0x48bee(%rip), %rsi     # 0x97fb0
movq %rsi, 0x28(%rsp)
callq 0x4a360
movq %rax, %rdi
movq 0x100(%rsp), %rsi
callq 0x4a300
movq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x4a360
movq 0x30(%rsp), %rdi
callq 0x4ddf0
movq %rax, 0x38(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x4a530
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x4dcf0
jmp 0x4f430
leaq 0x57(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4a530
movq 0x20(%rsp), %rdx
leaq 0x32cf9(%rip), %rsi     # 0x82144
leaq 0x58(%rsp), %rdi
callq 0x4dcf0
jmp 0x4f457
movq 0x38(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x57180
jmp 0x4f478
leaq 0x58(%rsp), %rdi
callq 0x4a5b8
leaq 0x57(%rsp), %rdi
callq 0x4a390
leaq 0x90(%rsp), %rdi
callq 0x4a5b8
leaq 0x8f(%rsp), %rdi
callq 0x4a390
leaq 0xb0(%rsp), %rdi
callq 0x572f0
movq %rax, 0x18(%rsp)
jmp 0x4f4ba
movq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x4f5b9
movq 0x48b08(%rip), %rdi     # 0x97fd8
leaq 0x33158(%rip), %rsi     # 0x8262f
callq 0x4a300
movq %rax, 0x10(%rsp)
jmp 0x4f4e3
leaq 0xb0(%rsp), %rdi
callq 0x57300
movq %rax, 0x8(%rsp)
jmp 0x4f4f7
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x4a2c0
movq %rax, (%rsp)
jmp 0x4f50c
movq (%rsp), %rdi
movq 0x48a99(%rip), %rsi     # 0x97fb0
callq 0x4a360
jmp 0x4f51e
leaq 0xb0(%rsp), %rdi
callq 0x57310
jmp 0x4f52d
jmp 0x4f4a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x4f58a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x4f573
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4a5b8
leaq 0x57(%rsp), %rdi
callq 0x4a390
leaq 0x90(%rsp), %rdi
callq 0x4a5b8
leaq 0x8f(%rsp), %rdi
callq 0x4a390
jmp 0x4f5ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x57320
jmp 0x4f5ce
leaq 0xb0(%rsp), %rdi
callq 0x57320
addq $0x118, %rsp            # imm = 0x118
retq
movq 0x80(%rsp), %rdi
callq 0x4a520
nopl (%rax,%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch_v2.cpp
// Function: void test_deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_deque(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::deque<K> elemQueue = json->wantDeque<K>(key);
	while (elemQueue.size())
	{
		cout<<"Element: "<<elemQueue.front()<<endl;
		elemQueue.pop_front();
	}
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x20(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x4877d(%rip), %rdi     # 0x97fd8
movq 0x4874e(%rip), %rsi     # 0x97fb0
movq %rsi, 0x18(%rsp)
callq 0x4a360
movq %rax, %rdi
movq 0xf0(%rsp), %rsi
callq 0x4a300
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x4a360
movq 0x20(%rsp), %rdi
callq 0x4ddf0
movq %rax, 0x28(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4a530
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x4dcf0
jmp 0x4f8cd
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4a530
movq 0x10(%rsp), %rdx
leaq 0x3285c(%rip), %rsi     # 0x82144
leaq 0x48(%rsp), %rdi
callq 0x4dcf0
jmp 0x4f8f4
movq 0x28(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rdx
leaq 0x48(%rsp), %rcx
callq 0x5a690
jmp 0x4f915
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
leaq 0x80(%rsp), %rdi
callq 0x4a5b8
leaq 0x7f(%rsp), %rdi
callq 0x4a390
leaq 0xa0(%rsp), %rdi
callq 0x580f0
cmpq $0x0, %rax
je 0x4fa2a
movq 0x4867a(%rip), %rdi     # 0x97fd8
leaq 0x32cca(%rip), %rsi     # 0x8262f
callq 0x4a300
movq %rax, 0x8(%rsp)
jmp 0x4f971
leaq 0xa0(%rsp), %rdi
callq 0x588f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4a2c0
movq %rax, (%rsp)
jmp 0x4f991
movq (%rsp), %rdi
movq 0x48614(%rip), %rsi     # 0x97fb0
callq 0x4a360
jmp 0x4f9a3
leaq 0xa0(%rsp), %rdi
callq 0x58950
jmp 0x4f940
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x4fa01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x4f9ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
leaq 0x80(%rsp), %rdi
callq 0x4a5b8
leaq 0x7f(%rsp), %rdi
callq 0x4a390
jmp 0x4fa3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x58a90
jmp 0x4fa3f
leaq 0xa0(%rsp), %rdi
callq 0x58a90
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x70(%rsp), %rdi
callq 0x4a520
nopl (%rax)
// File: swxlion[P]swxJson/tests/swxJsonAdvancedTest_fetch_v2.cpp
// Function: void test_list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::shared_ptr<swxJson::Json>, char const*, char const*)
void test_list(JsonPtr json, const char* key, const char* desc)
{
	cout<<endl<<desc<<endl;

	std::list<K> elemList = json->wantList<K>(key);
	for (auto& element: elemList)
		cout<<"Element: "<<element<<endl;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0x4833d(%rip), %rdi     # 0x97fd8
movq 0x4830e(%rip), %rsi     # 0x97fb0
movq %rsi, 0x20(%rsp)
callq 0x4a360
movq %rax, %rdi
movq 0xe0(%rsp), %rsi
callq 0x4a300
movq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x4a360
movq 0x28(%rsp), %rdi
callq 0x4ddf0
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x4a530
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x4dcf0
jmp 0x4fd10
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4a530
movq 0x18(%rsp), %rdx
leaq 0x32419(%rip), %rsi     # 0x82144
leaq 0x70(%rsp), %rdi
callq 0x4dcf0
jmp 0x4fd37
movq 0x30(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0x5add0
jmp 0x4fd58
leaq 0x70(%rsp), %rdi
callq 0x4a5b8
leaq 0x6f(%rsp), %rdi
callq 0x4a390
leaq 0xa8(%rsp), %rdi
callq 0x4a5b8
leaq 0xa7(%rsp), %rdi
callq 0x4a390
leaq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5af40
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x5af70
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5afa0
testb $0x1, %al
jne 0x4fdc9
jmp 0x4febc
leaq 0x58(%rsp), %rdi
callq 0x5afc0
movq %rax, 0x48(%rsp)
movq 0x481f9(%rip), %rdi     # 0x97fd8
leaq 0x32849(%rip), %rsi     # 0x8262f
callq 0x4a300
movq %rax, 0x10(%rsp)
jmp 0x4fdf2
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x4a2c0
movq %rax, 0x8(%rsp)
jmp 0x4fe08
movq 0x8(%rsp), %rdi
movq 0x4819c(%rip), %rsi     # 0x97fb0
callq 0x4a360
jmp 0x4fe1b
jmp 0x4fe1d
leaq 0x58(%rsp), %rdi
callq 0x5afe0
jmp 0x4fdb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4fe8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x4fe73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4a5b8
leaq 0x6f(%rsp), %rdi
callq 0x4a390
leaq 0xa8(%rsp), %rdi
callq 0x4a5b8
leaq 0xa7(%rsp), %rdi
callq 0x4a390
jmp 0x4fed1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x5b000
jmp 0x4fed1
leaq 0xc8(%rsp), %rdi
callq 0x5b000
addq $0xf8, %rsp
retq
movq 0x98(%rsp), %rdi
callq 0x4a520
nop