LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: exrok[P]evdoublebind/./src/evdoublebind.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc < 3) {
        perror("\
Error: Missing Arguments\n\
Consult `evdoublebind-make-config -h` for config details\n\
Usage: \n\
  evdoublebind <Keyboard> <Mapping>");
        exit(1);
    };
    nice(-20);
    int found = parse_keymap(argv[2]);
    map_events(argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x18cb
leaq 0x760(%rip), %rdi       # 0x201c
callq 0x1350
movl $0x1, %edi
callq 0x10b0
movl $0xffffffec, %edi       # imm = 0xFFFFFFEC
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1580
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: redpony[P]libpopt/optimize_test.cc
// Function: main
int main() {
  int n = 3;
  TestOptimizerVariants<SGDOptimizer>(n);
  TestOptimizerVariants<LBFGSOptimizer>(n);
  TestOptimizerVariants<RPropOptimizer>(n);
  cerr << "ALL OPTIMIZERS SUCCEEDED\n";
  return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movl $0x3, (%rsp)
movl (%rsp), %edi
callq 0x4930
movl (%rsp), %edi
callq 0x4c50
movl (%rsp), %edi
callq 0x4f70
movq 0xd9f1(%rip), %rdi      # 0x11ff0
leaq 0x9adb(%rip), %rsi      # 0xe0e1
callq 0x3210
xorl %eax, %eax
popq %rcx
retq
nop
// File: redpony[P]libpopt/./optimize.h
// Function: Optimizer::Optimize(double const&, std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>>*)
void Optimize(const double& obj,
                const std::vector<double>& g,
                std::vector<double>* x) {
    assert(g.size() == x->size());
    OptimizeImpl(obj, g, x);
    scitbx::lbfgs::traditional_convergence_test<double> converged(g.size());
    has_converged_ = converged(&(*x)[0], &g[0]);
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x52d0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x52d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x471a
jmp 0x4739
leaq 0x99da(%rip), %rdi      # 0xe0fb
leaq 0x99e9(%rip), %rsi      # 0xe111
movl $0x26, %edx
leaq 0x99ea(%rip), %rcx      # 0xe11e
callq 0x3150
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x30(%rsp), %rdi
callq 0x52d0
movq %rax, %rsi
leaq 0x18(%rsp), %rdi
movsd 0x98bb(%rip), %xmm0     # 0xe028
callq 0x52f0
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46b0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55a0
movq (%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x54d0
movb %al, %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0xc(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: redpony[P]libpopt/./lbfgs.h
// Function: scitbx::lbfgs::traditional_convergence_test<double, unsigned long>::traditional_convergence_test(unsigned long, double)
explicit
      traditional_convergence_test(
        SizeType n,
        FloatType eps = FloatType(1.e-5))
      : n_(n), eps_(eps)
      {
        if (n_ == 0) {
          throw error_improper_input_parameter("n = 0.");
        }
        if (eps_ < FloatType(0)) {
          throw error_improper_input_parameter("eps < 0.");
        }
      }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movsd %xmm0, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rcx
movq %rcx, (%rax)
movsd 0x90(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
cmpq $0x0, (%rax)
jne 0x53f6
movb $0x1, 0x5b(%rsp)
movl $0x28, %edi
callq 0x3100
movq %rax, 0x18(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x33c0
movq 0x20(%rsp), %rdx
leaq 0x8e0c(%rip), %rsi      # 0xe17b
leaq 0x70(%rsp), %rdi
callq 0x55c0
jmp 0x537b
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x5680
movq 0x18(%rsp), %rdi
movb $0x0, 0x5b(%rsp)
leaq 0xc70d(%rip), %rsi      # 0x11aa8
leaq 0x34e(%rip), %rdx       # 0x56f0
callq 0x3380
jmp 0x54cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x53d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3140
leaq 0x6f(%rsp), %rdi
callq 0x3270
testb $0x1, 0x5b(%rsp)
jne 0x53e7
jmp 0x53f1
movq 0x18(%rsp), %rdi
callq 0x3190
jmp 0x54c1
movq 0x28(%rsp), %rax
xorps %xmm0, %xmm0
ucomisd 0x8(%rax), %xmm0
jbe 0x54b9
movb $0x1, 0x36(%rsp)
movl $0x28, %edi
callq 0x3100
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x33c0
movq 0x10(%rsp), %rdx
leaq 0x8d4a(%rip), %rsi      # 0xe182
leaq 0x38(%rsp), %rdi
callq 0x55c0
jmp 0x5444
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5680
movq 0x8(%rsp), %rdi
movb $0x0, 0x36(%rsp)
leaq 0xc644(%rip), %rsi      # 0x11aa8
leaq 0x285(%rip), %rdx       # 0x56f0
callq 0x3380
jmp 0x54cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x549a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3140
leaq 0x37(%rsp), %rdi
callq 0x3270
testb $0x1, 0x36(%rsp)
jne 0x54ad
jmp 0x54b7
movq 0x8(%rsp), %rdi
callq 0x3190
jmp 0x54c1
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: redpony[P]libpopt/./lbfgs.h
// Function: scitbx::lbfgs::traditional_convergence_test<double, unsigned long>::operator()(double const*, double const*) const
bool
      operator()(const FloatType* x, const FloatType* g) const
      {
        FloatType xnorm = std::sqrt(detail::ddot(n_, x, x));
        FloatType gnorm = std::sqrt(detail::ddot(n_, g, g));
        if (gnorm <= eps_ * std::max(FloatType(1), xnorm)) return true;
        return false;
      }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x5c60
callq 0x31b0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x30(%rsp)
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x5c60
callq 0x31b0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8b10(%rip), %xmm0     # 0xe060
movsd %xmm0, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5cb0
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
mulsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jb 0x5582
movb $0x1, 0x57(%rsp)
jmp 0x5587
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: redpony[P]libpopt/optimize.cc
// Function: Optimizer::Save(std::ostream*) const
void Optimizer::Save(ostream* out) const {
  out->write((const char*)&eval_, sizeof(eval_));
  out->write((const char*)&has_converged_, sizeof(has_converged_));
  SaveImpl(out);
  unsigned int magic = 0xABCDDCBA;  // should be uint32_t
  out->write((const char*)&magic, sizeof(magic));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x8, %rsi
movl $0x4, %edx
callq 0x32e0
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0xc, %rsi
movl $0x1, %edx
callq 0x32e0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0xabcddcba, 0x14(%rsp) # imm = 0xABCDDCBA
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
movl $0x4, %edx
callq 0x32e0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]libpopt/optimize.cc
// Function: Optimizer::Load(std::istream*)
void Optimizer::Load(istream* in) {
  in->read((char*)&eval_, sizeof(eval_));
  ++eval_;
  in->read((char*)&has_converged_, sizeof(has_converged_));
  LoadImpl(in);
  unsigned int magic = 0;           // should be uint32_t
  in->read((char*)&magic, sizeof(magic));
  assert(magic == 0xABCDDCBA);
  cerr << Name() << " EVALUATION #" << eval_ << endl;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movq 0x68(%rsp), %rdi
addq $0x8, %rsi
movl $0x4, %edx
callq 0x32d0
movq 0x28(%rsp), %rsi
movl 0x8(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsi)
movq 0x68(%rsp), %rdi
addq $0xc, %rsi
movl $0x1, %edx
callq 0x32d0
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movl $0x0, 0x64(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x64(%rsp), %rsi
movl $0x4, %edx
callq 0x32d0
cmpl $0xabcddcba, 0x64(%rsp) # imm = 0xABCDDCBA
jne 0x7234
jmp 0x7253
leaq 0x719d(%rip), %rdi      # 0xe3d8
leaq 0x71aa(%rip), %rsi      # 0xe3ec
movl $0x29, %edx
leaq 0x71aa(%rip), %rcx      # 0xe3f8
callq 0x3150
movq 0x28(%rsp), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq *%rax
movq 0x18(%rsp), %rsi
movq 0xad79(%rip), %rdi      # 0x11ff0
callq 0x3200
movq %rax, 0x20(%rsp)
jmp 0x7283
movq 0x20(%rsp), %rdi
leaq 0x7189(%rip), %rsi      # 0xe418
callq 0x3210
movq %rax, 0x10(%rsp)
jmp 0x729b
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x33a0
movq %rax, 0x8(%rsp)
jmp 0x72b4
movq 0x8(%rsp), %rdi
movq 0xad00(%rip), %rsi      # 0x11fc0
callq 0x3250
jmp 0x72c7
leaq 0x40(%rsp), %rdi
callq 0x3140
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3140
movq 0x38(%rsp), %rdi
callq 0x33b0
nopl (%rax,%rax)
// File: redpony[P]libpopt/optimize.cc
// Function: RPropOptimizer::SaveImpl(std::ostream*) const
void RPropOptimizer::SaveImpl(ostream* out) const {
  const size_t n = prev_g_.size();
  out->write((const char*)&n, sizeof(n));
  out->write((const char*)&prev_g_[0], sizeof(double) * n);
  out->write((const char*)&delta_ij_[0], sizeof(double) * n);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x52d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
callq 0x32e0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
shlq $0x3, %rdx
callq 0x32e0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55a0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
shlq $0x3, %rdx
callq 0x32e0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]libpopt/optimize.cc
// Function: RPropOptimizer::LoadImpl(std::istream*)
void RPropOptimizer::LoadImpl(istream* in) {
  size_t n;
  in->read((char*)&n, sizeof(n));
  assert(n == prev_g_.size());
  assert(n == delta_ij_.size());
  in->read((char*)&prev_g_[0], sizeof(double) * n);
  in->read((char*)&delta_ij_[0], sizeof(double) * n);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x8, %edx
callq 0x32d0
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x10, %rdi
callq 0x52d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jne 0x7833
jmp 0x7852
leaq 0x6bfb(%rip), %rdi      # 0xe435
leaq 0x6bab(%rip), %rsi      # 0xe3ec
movl $0x59, %edx
leaq 0x6bfc(%rip), %rcx      # 0xe449
callq 0x3150
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
callq 0x52d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x7879
jmp 0x7898
leaq 0x6bfa(%rip), %rdi      # 0xe47a
leaq 0x6b65(%rip), %rsi      # 0xe3ec
movl $0x5a, %edx
leaq 0x6bb6(%rip), %rcx      # 0xe449
callq 0x3150
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
shlq $0x3, %rdx
callq 0x32d0
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x46b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
shlq $0x3, %rdx
callq 0x32d0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]libpopt/./lbfgs.h
// Function: scitbx::lbfgs::detail::mcsrch<double, unsigned long>::serialize(std::ostream*) const
void serialize(std::ostream* out) const {
          out->write((const char*)&infoc,sizeof(infoc));
          out->write((const char*)&dginit,sizeof(dginit));
          out->write((const char*)&brackt,sizeof(brackt));
          out->write((const char*)&stage1,sizeof(stage1));
          out->write((const char*)&finit,sizeof(finit));
          out->write((const char*)&dgtest,sizeof(dgtest));
          out->write((const char*)&width,sizeof(width));
          out->write((const char*)&width1,sizeof(width1));
          out->write((const char*)&stx,sizeof(stx));
          out->write((const char*)&fx,sizeof(fx));
          out->write((const char*)&dgx,sizeof(dgx));
          out->write((const char*)&sty,sizeof(sty));
          out->write((const char*)&fy,sizeof(fy));
          out->write((const char*)&dgy,sizeof(dgy));
          out->write((const char*)&stmin,sizeof(stmin));
          out->write((const char*)&stmax,sizeof(stmax));
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x10, %rsi
movl $0x1, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x11, %rsi
movl $0x1, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x18, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x20, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x28, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x30, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x38, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x40, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x48, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x50, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x58, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x60, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x68, %rsi
movl $0x8, %edx
callq 0x32e0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x70, %rsi
movl $0x8, %edx
callq 0x32e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: redpony[P]libpopt/./lbfgs.h
// Function: scitbx::lbfgs::detail::mcsrch<double, unsigned long>::deserialize(std::istream*) const
void deserialize(std::istream* in) const {
          in->read((char*)&infoc, sizeof(infoc));
          in->read((char*)&dginit, sizeof(dginit));
          in->read((char*)&brackt, sizeof(brackt));
          in->read((char*)&stage1, sizeof(stage1));
          in->read((char*)&finit, sizeof(finit));
          in->read((char*)&dgtest, sizeof(dgtest));
          in->read((char*)&width, sizeof(width));
          in->read((char*)&width1, sizeof(width1));
          in->read((char*)&stx, sizeof(stx));
          in->read((char*)&fx, sizeof(fx));
          in->read((char*)&dgx, sizeof(dgx));
          in->read((char*)&sty, sizeof(sty));
          in->read((char*)&fy, sizeof(fy));
          in->read((char*)&dgy, sizeof(dgy));
          in->read((char*)&stmin, sizeof(stmin));
          in->read((char*)&stmax, sizeof(stmax));
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x8, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x10, %rsi
movl $0x1, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x11, %rsi
movl $0x1, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x18, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x20, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x28, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x30, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x38, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x40, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x48, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x50, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x58, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x60, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x68, %rsi
movl $0x8, %edx
callq 0x32d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x70, %rsi
movl $0x8, %edx
callq 0x32d0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: moya-lang[P]Arguments/Example1.cpp
// Function: parseArguments(int, char const**)
void parseArguments(int argc, const char **argv)
{
    Syntax syntax("My simple command-line tool", "1.0.0.1");
    Arguments arguments(argc, argv);
    Parser parser(syntax, arguments);
    if (parser.parse())
        return;

    Help help(syntax, parser, arguments);
    exit(help.run());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x33a0
movq -0x148(%rbp), %rdx
leaq 0x5a91(%rip), %rsi      # 0x9004
leaq -0x88(%rbp), %rdi
callq 0x37b0
jmp 0x3581
leaq -0xc1(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x33a0
movq -0x150(%rbp), %rdx
leaq 0x5a7e(%rip), %rsi      # 0x9020
leaq -0xc0(%rbp), %rdi
callq 0x37b0
jmp 0x35b0
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x3860
jmp 0x35c9
leaq -0xc0(%rbp), %rdi
callq 0x3140
leaq -0xc1(%rbp), %rdi
callq 0x3260
leaq -0x88(%rbp), %rdi
callq 0x3140
leaq -0x89(%rbp), %rdi
callq 0x3260
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
callq 0x38d0
jmp 0x360e
leaq -0x118(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x3900
jmp 0x3627
leaq -0x118(%rbp), %rdi
callq 0x3940
movb %al, -0x151(%rbp)
jmp 0x363b
movb -0x151(%rbp), %al
testb $0x1, %al
jne 0x364a
jmp 0x3708
leaq -0x118(%rbp), %rdi
callq 0x3dd0
leaq -0x68(%rbp), %rdi
callq 0x3df0
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x36ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x3140
leaq -0xc1(%rbp), %rdi
callq 0x3260
leaq -0x88(%rbp), %rdi
callq 0x3140
leaq -0x89(%rbp), %rdi
callq 0x3260
jmp 0x3750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x3747
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3dd0
jmp 0x3747
leaq -0x140(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x118(%rbp), %rdx
leaq -0xd8(%rbp), %rcx
callq 0x3a70
jmp 0x3728
leaq -0x140(%rbp), %rdi
callq 0x3ac0
movl %eax, -0x158(%rbp)
jmp 0x373c
movl -0x158(%rbp), %edi
callq 0x32b0
leaq -0x68(%rbp), %rdi
callq 0x3df0
movq -0x98(%rbp), %rdi
callq 0x3390
nopl (%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Parser::parse()
bool parse()
        {
            const size_t numberOfCommands = syntax.commands.size();
            const char *commandName = arguments[1];

            if (!commandName && numberOfCommands != 1)
                return numberOfCommands == 0;

            if (commandName && isVersionCommandName(commandName)) {
                parseVersionCommand();
                return false;
            }

            if (commandName && isHelpCommandName(commandName)) {
                parseHelpCommand();
                return false;
            }

            if (numberOfCommands == 1)
                return parseParameters(syntax.commands.front());

            const Command *command = syntax.findCommandByName(commandName);
            return command ? parseParameters(*command) : false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x30(%rax), %rdi
addq $0x40, %rdi
callq 0x4040
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x4070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x399e
cmpq $0x1, -0x18(%rbp)
je 0x399e
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a5b
cmpq $0x0, -0x20(%rbp)
je 0x39ca
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x40c0
testb $0x1, %al
jne 0x39b8
jmp 0x39ca
movq -0x30(%rbp), %rdi
callq 0x4130
movb $0x0, -0x1(%rbp)
jmp 0x3a5b
cmpq $0x0, -0x20(%rbp)
je 0x39f3
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x41d0
testb $0x1, %al
jne 0x39e4
jmp 0x39f3
movq -0x30(%rbp), %rdi
callq 0x4240
movb $0x0, -0x1(%rbp)
jmp 0x3a5b
cmpq $0x1, -0x18(%rbp)
jne 0x3a1e
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x40, %rdi
callq 0x4900
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4540
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3a5b
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4930
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3a4c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4540
movb %al, -0x31(%rbp)
jmp 0x3a53
xorl %eax, %eax
movb %al, -0x31(%rbp)
jmp 0x3a53
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Syntax::findCommandByName(char const*) const
const Command *findCommandByName(const char *name) const
        {
            for (const Command &command : commands)
                if (command.name == name)
                    return &command;

            return nullptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6020
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x60f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6120
testb $0x1, %al
jne 0x4979
jmp 0x49b4
leaq -0x28(%rbp), %rdi
callq 0x6050
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x5b90
testb $0x1, %al
jne 0x499d
jmp 0x49a7
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x49bc
jmp 0x49a9
leaq -0x28(%rbp), %rdi
callq 0x6150
jmp 0x4966
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Syntax::findParameterByName(Moya::System::Arguments::Command const&, char const*) const
const Parameter *findParameterByName(const Command &command, const char *name) const
        {
            for (const Parameter &parameter : command.parameters)
                if (parameter.name == name)
                    return &parameter;

            return nullptr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5ad0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5b00
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5b30
testb $0x1, %al
jne 0x579f
jmp 0x57da
leaq -0x30(%rbp), %rdi
callq 0x5b60
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq -0x20(%rbp), %rsi
callq 0x5b90
testb $0x1, %al
jne 0x57c3
jmp 0x57cd
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x57e2
jmp 0x57cf
leaq -0x30(%rbp), %rdi
callq 0x5bc0
jmp 0x578c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Parser::areAllRequiredParametersSpecified(Moya::System::Arguments::Command const&) const
bool areAllRequiredParametersSpecified(const Command &command) const
        {
            for (const Parameter &parameter : command.parameters)
                if (parameter.isRequired && find("/" + parameter.identifier) == end())
                    return false;

            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5ad0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5b00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5b30
testb $0x1, %al
jne 0x59bc
jmp 0x5aa8
leaq -0x28(%rbp), %rdi
callq 0x5b60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb 0x60(%rax), %cl
movb $0x0, -0x61(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x89(%rbp)
je 0x5a4a
movq -0x38(%rbp), %rdx
leaq 0x3669(%rip), %rsi      # 0x9055
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x57f0
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movb $0x1, -0x61(%rbp)
callq 0x5db0
movq %rax, -0x98(%rbp)
jmp 0x5a1c
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x5de0
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x5d80
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
movb %al, -0xa1(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x5a5e
jmp 0x5a67
leaq -0x60(%rbp), %rdi
callq 0x3140
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x5a73
jmp 0x5a98
movb $0x0, -0x1(%rbp)
jmp 0x5aac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x5a8d
jmp 0x5a96
leaq -0x60(%rbp), %rdi
callq 0x3140
jmp 0x5aba
jmp 0x5a9a
leaq -0x28(%rbp), %rdi
callq 0x5bc0
jmp 0x59a6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Help::computeMaxIntroLengths()
void computeMaxIntroLengths()
        {
            for (const Command &command : syntax.commands) {

                size_t commandIntroLength = 2 * margin + command.name.length();
                if (maxCommandIntroLength < commandIntroLength)
                    maxCommandIntroLength = commandIntroLength;

                for (const Parameter &parameter : command.parameters) {

                    size_t parameterIntroLength = 2 * margin + parameter.name.length();
                    if (parameter.hasValue)
                        parameterIntroLength += 3 + parameter.identifier.length();

                    if (maxParameterIntroLength < parameterIntroLength)
                        maxParameterIntroLength = parameterIntroLength;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq (%rax), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6020
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6120
testb $0x1, %al
jne 0x61bf
jmp 0x62b1
leaq -0x18(%rbp), %rdi
callq 0x6050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x3320
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq $0x6, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
cmpq -0x30(%rbp), %rax
jae 0x61fe
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5ad0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x5b00
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5b30
testb $0x1, %al
jne 0x6239
jmp 0x62a1
leaq -0x40(%rbp), %rdi
callq 0x5b60
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x3320
addq $0x6, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
testb $0x1, 0x61(%rax)
je 0x627a
movq -0x50(%rbp), %rdi
callq 0x3320
addq $0x3, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x58(%rbp), %rax
jae 0x6294
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x6296
leaq -0x40(%rbp), %rdi
callq 0x5bc0
jmp 0x6226
jmp 0x62a3
leaq -0x18(%rbp), %rdi
callq 0x6150
jmp 0x61a9
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: moya-lang[P]Arguments/./Arguments.h
// Function: Moya::System::Arguments::Help::getApplicationName[abi:cxx11]() const
std::string getApplicationName() const
        {
            const char *applicationName = strrchr(arguments[0], '/');
            if (applicationName)
                return applicationName + 1;

            applicationName = strrchr(arguments[0], '\\');
            if (applicationName)
                return applicationName + 1;

            return arguments[0];
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4070
movq %rax, %rdi
movl $0x2f, %esi
callq 0x3290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x767e
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x58(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x33a0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x37b0
jmp 0x7656
leaq -0x19(%rbp), %rdi
callq 0x3260
jmp 0x774b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x3260
jmp 0x7758
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4070
movq %rax, %rdi
movl $0x5c, %esi
callq 0x3290
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x76f4
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x68(%rbp)
leaq -0x2d(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x33a0
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x37b0
jmp 0x76d2
leaq -0x2d(%rbp), %rdi
callq 0x3260
jmp 0x774b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2d(%rbp), %rdi
callq 0x3260
jmp 0x7758
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4070
movq %rax, -0x78(%rbp)
leaq -0x2e(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x33a0
movq -0x48(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x37b0
jmp 0x7729
leaq -0x2e(%rbp), %rdi
callq 0x3260
jmp 0x774b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x2e(%rbp), %rdi
callq 0x3260
jmp 0x7758
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3390
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: SamKG[P]Flush-Reload-Sidechannel/util.cpp
// Function: get_highres_time()
CYCLES get_highres_time(){
	volatile uint32_t time_lo;
	volatile uint32_t time_hi;
	asm volatile(
	"rdtsc\n"
	: "=a"(time_lo),"=d"(time_hi));
	CYCLES time = (uint64_t)time_lo | (( (uint64_t) time_hi) <<32);
//	printf("GOT TIME %Ld\n",time);
	return time;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
rdtsc
movl %eax, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %eax
movl -0x8(%rbp), %ecx
movl %ecx, %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: SamKG[P]Flush-Reload-Sidechannel/util.cpp
// Function: probe_one_block(unsigned long)
CYCLES probe_one_block(ADDR_PTR adrs) {
  CYCLES time;

  asm __volatile__ (
    "  mfence             \n"
    "  lfence             \n"
    "  rdtsc              \n"
    "  lfence             \n"
    "  movl %%eax, %%esi  \n"
    "  movl (%1), %%eax   \n"
    "  lfence             \n"
    "  rdtsc              \n"
    "  subl %%esi, %%eax  \n"
    "  clflush 0(%1)      \n"
    : "=a" (time)
    : "c" (adrs)
    :  "%esi", "%edx");
  return time;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
mfence
lfence
rdtsc
lfence
movl %eax, %esi
movl (%rcx), %eax
lfence
rdtsc
subl %esi, %eax
clflush (%rcx)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nop
// File: GodOfProgramming[P]cspec/src/benchmark.cpp
// Function: cspec::Benchmark::Benchmark(char const*)
Benchmark::Benchmark(const char* name): Name(name)
	{
		if (!gBenchmarkInitalized) {
			Benchmarks = std::make_unique<std::deque<Benchmark*>>();
			gBenchmarkInitalized = true;
		}

		Benchmarks->push_back(this);
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x17322(%rip), %rcx     # 0x33fe0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0x18853(%rip)     # 0x35528
jne 0x1cd03
leaq 0x10(%rsp), %rdi
callq 0x1af70
movq 0x17298(%rip), %rdi     # 0x33f80
leaq 0x10(%rsp), %rsi
callq 0x1ab50
leaq 0x10(%rsp), %rdi
callq 0x1c9d8
movb $0x1, 0x18825(%rip)     # 0x35528
movq 0x17276(%rip), %rdi     # 0x33f80
callq 0x1aaf0
movq %rax, %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x1c040
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: GodOfProgramming[P]cspec/src/benchmark.cpp
// Function: cspec::Benchmark::Run()
void Benchmark::Run()
	{
		std::cout << "Running " << Benchmarks->size() << " benchmarks\n";
		for (auto benchmark : *Benchmarks) {
			std::cout << "\n\n" << benchmark->Name << "\n\n";
			benchmark->body();
		}
	}

// Assembly:
subq $0x58, %rsp
movq 0x17265(%rip), %rdi     # 0x33fa0
leaq 0xf2be(%rip), %rsi      # 0x2c000
callq 0x1b3a0
movq %rax, (%rsp)
movq 0x1722e(%rip), %rdi     # 0x33f80
callq 0x1aaf0
movq %rax, %rdi
callq 0x1c860
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1a3a0
movq %rax, %rdi
leaq 0xf294(%rip), %rsi      # 0x2c009
callq 0x1b3a0
movq 0x171ff(%rip), %rdi     # 0x33f80
callq 0x1b0e0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1ae30
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1bbb0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b890
testb $0x1, %al
jne 0x1cdbe
jmp 0x1ce19
leaq 0x30(%rsp), %rdi
callq 0x1bfc0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x171c9(%rip), %rdi     # 0x33fa0
leaq 0xf238(%rip), %rsi      # 0x2c016
callq 0x1b3a0
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1b3a0
movq %rax, %rdi
leaq 0xf218(%rip), %rsi      # 0x2c016
callq 0x1b3a0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
leaq 0x30(%rsp), %rdi
callq 0x1afe0
jmp 0x1cda9
addq $0x58, %rsp
retq
nop
// File: GodOfProgramming[P]cspec/include/cspec/internal/blocks.hpp
// Function: cspec::ItBlock::run()
inline void ItBlock::run()
  {
    for (const auto& test : PrevTests) {
      if (test->beforeEach) {
        test->beforeEach();
      }
    }

    TestBlock::run();

    for (const auto& test : PrevTests) {
      if (test->afterEach) {
        test->afterEach();
      }
    }
  }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x70, %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1c1a0
movq 0xa8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x1c5c0
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1bc00
testb $0x1, %al
jne 0x1cee7
jmp 0x1cf32
leaq 0x88(%rsp), %rdi
callq 0x1a380
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x1c4e0
testb $0x1, %al
jne 0x1cf10
jmp 0x1cf21
movq 0x60(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
callq 0x1b340
jmp 0x1cf23
leaq 0x88(%rsp), %rdi
callq 0x1b4b0
jmp 0x1cecf
movq 0x8(%rsp), %rdi
callq 0x1a170
movq 0x8(%rsp), %rax
addq $0x70, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x1c1a0
movq 0x58(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1c5c0
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1bc00
testb $0x1, %al
jne 0x1cf7d
jmp 0x1cfc2
leaq 0x38(%rsp), %rdi
callq 0x1a380
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x1c4e0
testb $0x1, %al
jne 0x1cfa3
jmp 0x1cfb4
movq 0x10(%rsp), %rax
movq (%rax), %rdi
addq $0x28, %rdi
callq 0x1b340
jmp 0x1cfb6
leaq 0x38(%rsp), %rdi
callq 0x1b4b0
jmp 0x1cf68
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::RunTest(cspec::TestBlock&)
void RunTest(TestBlock& test)
  {
    try {
      test.run();
    } catch (InvalidExpectationException e) {
      print('\n', e.File, " (", e.Line, "): ", "Expectations can only be executed within it blocks", '\n');
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x1f1d9
jmp 0x1f24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1f269
movq 0x28(%rsp), %rdi
callq 0x1a740
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movb $0xa, 0xf(%rsp)
leaq 0x18(%rsp), %rcx
movb $0xa, 0xe(%rsp)
movq %rsp, %rax
leaq 0xe(%rsp), %rdx
movq %rdx, (%rax)
leaq 0xce91(%rip), %rdx      # 0x2c0ba
leaq 0xce8d(%rip), %r8       # 0x2c0bd
leaq 0xce8a(%rip), %r9       # 0x2c0c1
leaq 0xf(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b270
jmp 0x1f248
callq 0x1c270
addq $0x38, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x1c270
jmp 0x1f267
jmp 0x1f269
movq 0x28(%rsp), %rdi
callq 0x1c550
movq %rax, %rdi
callq 0x1d520
nopl (%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::_Describe_(char const*, std::function<void ()>)
void _Describe_(const char* desc, TestFunc func)
  {
    auto prev_test = gRunningTest;
    cspec::DescribeBlock db(desc, func);
    gRunningTest = &db;
    gRunningTests.push_back(gRunningTest);
    RunTest(db);
    gRunningTests.pop_back();
    gRunningTest = prev_test;
  }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0x164d2(%rip), %rax     # 0x35770
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1beb0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x1b9f0
jmp 0x1f2d6
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
leaq 0x40(%rsp), %rax
movq %rax, 0x16484(%rip)     # 0x35770
leaq 0x1647d(%rip), %rsi     # 0x35770
leaq 0x1628e(%rip), %rdi     # 0x35588
callq 0x1b230
jmp 0x1f301
leaq 0x40(%rsp), %rdi
callq 0x1bf00
jmp 0x1f30d
leaq 0x16274(%rip), %rdi     # 0x35588
callq 0x1a840
movq 0xb0(%rsp), %rax
movq %rax, 0x16448(%rip)     # 0x35770
leaq 0x40(%rsp), %rdi
callq 0x1b0d0
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
jmp 0x1f36c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1b0d0
movq 0x18(%rsp), %rdi
callq 0x1c550
nopw %cs:(%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::_Context_(char const*, std::function<void ()>)
void _Context_(const char* context, TestFunc func)
  {
    auto prev_test = gRunningTest;
    ContextBlock cb(context, func);
    gRunningTest = &cb;
    gRunningTests.push_back(gRunningTest);
    RunTest(cb);
    gRunningTests.pop_back();
    gRunningTest = prev_test;
  }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0x163d2(%rip), %rax     # 0x35770
movq %rax, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1beb0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x1b410
jmp 0x1f3d6
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
leaq 0x40(%rsp), %rax
movq %rax, 0x16384(%rip)     # 0x35770
leaq 0x1637d(%rip), %rsi     # 0x35770
leaq 0x1618e(%rip), %rdi     # 0x35588
callq 0x1b230
jmp 0x1f401
leaq 0x40(%rsp), %rdi
callq 0x1bf00
jmp 0x1f40d
leaq 0x16174(%rip), %rdi     # 0x35588
callq 0x1a840
movq 0xb0(%rsp), %rax
movq %rax, 0x16348(%rip)     # 0x35770
leaq 0x40(%rsp), %rdi
callq 0x1a550
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
jmp 0x1f46c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a550
movq 0x18(%rsp), %rdi
callq 0x1c550
nopw %cs:(%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::_It_(char const*, std::function<void ()>)
void _It_(const char* test, TestFunc func)
  {
    auto prev_test = gRunningTest;
    ItBlock ib(test, func);
    ib.PrevTests = gRunningTests;
    gRunningTest = &ib;
    gRunningTests.push_back(gRunningTest);

    gInItBlock = true;
    RunTest(ib);
    gInItBlock = false;

    gSpecCount++;

    if (Failable::ItFailed) {
      gFailures++;
      Failable::ItFailed = false;
      print("\x1b[31m\u00D7");
    } else {
      print("\x1b[32m\u2022");
    }

    gRunningTests.pop_back();
    gRunningTest = prev_test;
  }

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq 0x162d2(%rip), %rax     # 0x35770
movq %rax, 0x100(%rsp)
movq 0x110(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1beb0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x1a980
jmp 0x1f4d6
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
leaq 0xb0(%rsp), %rdi
leaq 0x16099(%rip), %rsi     # 0x35588
callq 0x1b590
jmp 0x1f4f6
leaq 0x40(%rsp), %rax
movq %rax, 0x1626e(%rip)     # 0x35770
leaq 0x16267(%rip), %rsi     # 0x35770
leaq 0x16078(%rip), %rdi     # 0x35588
callq 0x1b230
jmp 0x1f517
movq 0x14a92(%rip), %rax     # 0x33fb0
movb $0x1, (%rax)
leaq 0x40(%rsp), %rdi
callq 0x1bf00
jmp 0x1f52d
movq 0x14a7c(%rip), %rax     # 0x33fb0
movb $0x0, (%rax)
movq 0x14a5a(%rip), %rax     # 0x33f98
movl (%rax), %ecx
addl $0x1, %ecx
movq 0x14a4e(%rip), %rax     # 0x33f98
movl %ecx, (%rax)
movq 0x14a55(%rip), %rax     # 0x33fa8
testb $0x1, (%rax)
je 0x1f5b3
movq 0x14a09(%rip), %rax     # 0x33f68
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
movq 0x14a3c(%rip), %rax     # 0x33fa8
movb $0x0, (%rax)
leaq 0xcb7e(%rip), %rdi      # 0x2c0f4
callq 0x1a580
jmp 0x1f57d
jmp 0x1f5c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1a6c0
jmp 0x1f5f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a5e0
jmp 0x1f5f0
leaq 0xcb42(%rip), %rdi      # 0x2c0fc
callq 0x1c1b0
jmp 0x1f5c1
jmp 0x1f5c3
leaq 0x15fbe(%rip), %rdi     # 0x35588
callq 0x1a840
movq 0x100(%rsp), %rax
movq %rax, 0x16192(%rip)     # 0x35770
leaq 0x40(%rsp), %rdi
callq 0x1a5e0
addq $0x118, %rsp            # imm = 0x118
retq
movq 0x18(%rsp), %rdi
callq 0x1c550
nopw (%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::init_env()
void init_env()
  {
    for (int i = 0; environ[i] != nullptr; i++) {
      std::string env = environ[i];

      auto eqpos = env.find_first_of('=');
      auto k = env.substr(0, eqpos);
      auto v = env.substr(eqpos + 1);

      ENV[k] = v;
    }
  }

// Assembly:
subq $0xb8, %rsp
movl $0x0, 0xb4(%rsp)
movq 0x1491f(%rip), %rax     # 0x33fb8
movq (%rax), %rax
movslq 0xb4(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1f83f
movq 0x14902(%rip), %rax     # 0x33fb8
movq (%rax), %rax
movslq 0xb4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1c560
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x1c400
jmp 0x1f6f5
leaq 0x8f(%rsp), %rdi
callq 0x1b5f0
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x18(%rsp)
leaq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3d, %esi
callq 0x1ab60
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0x1b4c0
jmp 0x1f742
movq 0x70(%rsp), %rdx
incq %rdx
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq $-0x1, %rcx
callq 0x1b4c0
jmp 0x1f765
movq 0x147dc(%rip), %rdi     # 0x33f48
leaq 0x50(%rsp), %rsi
callq 0x1b440
movq %rax, 0x8(%rsp)
jmp 0x1f77d
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1a090
jmp 0x1f78e
leaq 0x30(%rsp), %rdi
callq 0x1ab20
leaq 0x50(%rsp), %rdi
callq 0x1ab20
leaq 0x90(%rsp), %rdi
callq 0x1ab20
movl 0xb4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb4(%rsp)
jmp 0x1f692
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0x1b5f0
jmp 0x1f847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1f830
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1f826
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1ab20
leaq 0x50(%rsp), %rdi
callq 0x1ab20
leaq 0x90(%rsp), %rdi
callq 0x1ab20
jmp 0x1f847
addq $0xb8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x1c550
nopw %cs:(%rax,%rax)
// File: GodOfProgramming[P]cspec/src/cspec.cpp
// Function: cspec::run_tests(int, char**)
auto run_tests(int argc, char* argv[]) -> bool
  {
    init_env();
    init_argv(argc, argv);

    // if --no-eval is not present
    if (!check_opt("--no-eval")) {
      cspec::Evaluation::Run();

      cspec::print('\n', cspec::captures());

      cspec::print("\n\n",
       "Evaluated ",
       cspec::gSpecCount,
       " test",
       cspec::gSpecCount == 1 ? "" : "s",
       " with ",
       cspec::gFailures,
       " failure",
       cspec::gFailures == 1 ? "" : "s",
       '\n');
    }

    if (check_opt("--bench")) {
      cspec::Benchmark::Run();
    }

    return cspec::gFailures == 0;
  }

// Assembly:
pushq %rbx
subq $0x90, %rsp
movl %edi, 0x8c(%rsp)
movq %rsi, 0x80(%rsp)
callq 0x1c670
movl 0x8c(%rsp), %edi
movq 0x80(%rsp), %rsi
callq 0x1b960
leaq 0xc67e(%rip), %rdi      # 0x2c105
callq 0x1bd90
testb $0x1, %al
jne 0x1fb87
callq 0x1c010
movb $0xa, 0x7f(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1ab10
movq 0x28(%rsp), %rsi
leaq 0x7f(%rsp), %rdi
callq 0x1b650
jmp 0x1fabe
leaq 0x58(%rsp), %rdi
callq 0x1ab20
movq 0x144c9(%rip), %rax     # 0x33f98
movl (%rax), %edx
leaq 0xc61a(%rip), %rax      # 0x2c0f2
leaq 0xc539(%rip), %rcx      # 0x2c018
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x14476(%rip), %rax     # 0x33f68
movl (%rax), %edx
leaq 0xc5f7(%rip), %rax      # 0x2c0f2
leaq 0xc516(%rip), %rcx      # 0x2c018
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, 0x38(%rsp)
movb $0xa, 0x37(%rsp)
leaq 0xc4fc(%rip), %rdi      # 0x2c016
leaq 0xc5ee(%rip), %rsi      # 0x2c10f
movq 0x14470(%rip), %rdx     # 0x33f98
leaq 0xc5eb(%rip), %rcx      # 0x2c11a
leaq 0x40(%rsp), %r8
leaq 0xc5e5(%rip), %r9       # 0x2c120
movq 0x14426(%rip), %rbx     # 0x33f68
leaq 0xc5de(%rip), %r11      # 0x2c127
leaq 0x38(%rsp), %r10
leaq 0x37(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x1a4c0
jmp 0x1fb87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1ab20
jmp 0x1fbb6
leaq 0xc5a2(%rip), %rdi      # 0x2c130
callq 0x1bd90
testb $0x1, %al
jne 0x1fb99
jmp 0x1fb9e
callq 0x1bd20
movq 0x143c3(%rip), %rax     # 0x33f68
cmpl $0x0, (%rax)
sete %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbx
retq
movq 0x50(%rsp), %rdi
callq 0x1c550
// File: GodOfProgramming[P]cspec/src/evaluation.cpp
// Function: cspec::Evaluation::Evaluation(char const*)
Evaluation::Evaluation(char const* test_name): Name(test_name)
  {
    if (!gEvaluationInitalized) {
      Tests = std::make_unique<std::deque<Evaluation*>>();
      gEvaluationInitalized = true;
    }
    Tests->push_back(this);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0xc332(%rip), %rcx      # 0x33fd0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0xdad3(%rip)      # 0x35788
jne 0x27ce3
leaq 0x10(%rsp), %rdi
callq 0x1b310
movq 0xc2f8(%rip), %rdi      # 0x33fc0
leaq 0x10(%rsp), %rsi
callq 0x1a5b0
leaq 0x10(%rsp), %rdi
callq 0x1c9e0
movb $0x1, 0xdaa5(%rip)      # 0x35788
movq 0xc2d6(%rip), %rdi      # 0x33fc0
callq 0x1c3a0
movq %rax, %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x1c4d0
addq $0x28, %rsp
retq
nopw (%rax,%rax)