LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nicklausw[P]snesasm/snesasm.cpp
// Function: raw_data(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void raw_data(int range, string name)
{
  while (hint_next_token().token_type != tkNL) {
    if (hint_next_token().token_type == tkCOMMA) {
      pass_counter++; continue;
    }
    
    directive_arg(name, range);
    
    if (range == r8) {
      write_byte(tr & 0xFF);
    } else if (range == r16) {
      write_byte(tr >> 8);
      write_byte(tr & 0xFF);
    }
  }
}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x20(%rsp)
movl %edi, 0xb4(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xc5a0
movl 0x80(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x9b1b(%rip), %eax      # 0x161f4
movl %eax, 0x18(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd410
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
je 0xc7f2
leaq 0x58(%rsp), %rdi
callq 0xc5a0
movl 0x58(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x9ae6(%rip), %eax      # 0x161f8
movl %eax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xd410
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jne 0xc743
movq 0x9bfd(%rip), %rax      # 0x16330
addq $0x1, %rax
movq %rax, 0x9bf2(%rip)      # 0x16330
jmp 0xc6bb
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x20d0
movq 0x8(%rsp), %rdi
movl 0xb4(%rsp), %esi
callq 0xc270
jmp 0xc76a
leaq 0x38(%rsp), %rdi
callq 0x23a8
movl 0xb4(%rsp), %eax
cmpl 0x9a7f(%rip), %eax      # 0x16200
jne 0xc7b4
movq 0x9b46(%rip), %rax      # 0x162d0
andq $0xff, %rax
movzbl %al, %edi
callq 0xc810
jmp 0xc7ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x23a8
jmp 0xc7fa
movl 0xb4(%rsp), %eax
cmpl 0x9a43(%rip), %eax      # 0x16204
jne 0xc7eb
movq 0x9b06(%rip), %rax      # 0x162d0
sarq $0x8, %rax
movzbl %al, %edi
callq 0xc810
movq 0x9af3(%rip), %rax      # 0x162d0
andq $0xff, %rax
movzbl %al, %edi
callq 0xc810
jmp 0xc7ed
jmp 0xc6bb
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: nicklausw[P]snesasm/snesasm.cpp
// Function: write_byte(unsigned char)
void write_byte(unsigned char byte)
{
  // the surprisingly simplest function of all!
  rom[org-base] = byte; org++;
  
  // ...well, that's before bug checks came in
  if (org > (base*(cur_bank+2))) {
    if (cur_bank >= rombanks) {
      cerr << "error: no more room in rom\n";
      exit(fail);
    } else {
      cerr << "warning: bank overflow; rolling into bank " << cur_bank+1 << "\n";
      cerr << "org: " << org << " base: " << base << " banksize: " << banksize << "\n";
      cur_bank++;
    }
  }
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movb %al, 0x6(%rsp)
movq 0x99f1(%rip), %rsi      # 0x16218
subq 0x99e2(%rip), %rsi      # 0x16210
leaq 0x9aa3(%rip), %rdi      # 0x162d8
callq 0xd590
movb 0x6(%rsp), %cl
movb %cl, (%rax)
movq 0x99d1(%rip), %rax      # 0x16218
addq $0x1, %rax
movq %rax, 0x99c6(%rip)      # 0x16218
movq 0x99bf(%rip), %rax      # 0x16218
movq 0x99b0(%rip), %rcx      # 0x16210
movq 0x9a59(%rip), %rdx      # 0x162c0
addq $0x2, %rdx
imulq %rdx, %rcx
cmpq %rcx, %rax
jbe 0xc95e
movq 0x9a41(%rip), %rax      # 0x162c0
movzbl 0x9a30(%rip), %ecx      # 0x162b6
cmpq %rcx, %rax
jb 0xc8a8
movq 0x975e(%rip), %rdi      # 0x15ff0
leaq 0x4c6e(%rip), %rsi      # 0x11507
callq 0x21b0
movl $0x1, %edi
callq 0x21f0
movq 0x9741(%rip), %rdi      # 0x15ff0
leaq 0x4c6d(%rip), %rsi      # 0x11523
callq 0x21b0
movq %rax, %rdi
movq 0x99fb(%rip), %rsi      # 0x162c0
addq $0x1, %rsi
callq 0x2050
movq %rax, %rdi
leaq 0x48d6(%rip), %rsi      # 0x111ae
callq 0x21b0
movq 0x970c(%rip), %rdi      # 0x15ff0
leaq 0x4c63(%rip), %rsi      # 0x1154e
callq 0x21b0
movq %rax, %rdi
movq 0x991e(%rip), %rsi      # 0x16218
callq 0x2050
movq %rax, %rdi
leaq 0x4c4b(%rip), %rsi      # 0x11554
callq 0x21b0
movq %rax, %rdi
movq 0x98f8(%rip), %rsi      # 0x16210
callq 0x2050
movq %rax, %rdi
leaq 0x4c35(%rip), %rsi      # 0x1155c
callq 0x21b0
movq %rax, %rdi
movq 0x9982(%rip), %rsi      # 0x162b8
callq 0x2050
movq %rax, %rdi
leaq 0x4869(%rip), %rsi      # 0x111ae
callq 0x21b0
movq 0x996f(%rip), %rax      # 0x162c0
addq $0x1, %rax
movq %rax, 0x9964(%rip)      # 0x162c0
jmp 0xc95e
popq %rax
retq
// File: tomfunkhouser[P]gaps/apps/grd2msh/grd2msh.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read grid
  R3Grid *grid = ReadGrid(grid_name);
  if (!grid) exit(-1);

  // Create isosurface
  R3Mesh *mesh = CreateMesh(grid, threshold);
  if (!mesh) exit(-1);

  // Write mesh
  int status = WriteMesh(mesh, mesh_name);
  if (!status) exit(-1);

  // Return success 
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x12570
cmpl $0x0, %eax
jne 0x124f2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x166067(%rip), %rdi    # 0x178560
callq 0x12710
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12515
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x10(%rsp), %rdi
movsd 0x166046(%rip), %xmm0   # 0x178568
callq 0x12bb0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1253e
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
movq 0x8(%rsp), %rdi
movq 0x166026(%rip), %rsi    # 0x178570
callq 0x12f80
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x12564
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xf600
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grd2msh/grd2msh.cpp
// Function: ParseArgs(int, char**)
static int 
ParseArgs(int argc, char **argv)
{
  // Check number of arguments
  if ((argc == 2) && (*argv[1] == '-')) {
    printf("Usage: grd2off gridfile meshfile -threshold <real> [-v]\n");
    exit(0);
  }

  // Parse arguments
  argc--; argv++;
  while (argc > 0) {
    if ((*argv)[0] == '-') {
      if (!strcmp(*argv, "-v")) print_verbose = TRUE; 
      else if (!strcmp(*argv, "-threshold")) { argc--; argv++; threshold = atof(*argv); }
      else { 
        RNFail("Invalid program argument: %s\n", *argv); 
        exit(1); 
      }
      argv++; argc--;
    }
    else {
      if (!grid_name) grid_name = *argv;
      else if (!mesh_name) mesh_name = *argv;
      else { 
        RNFail("Invalid program argument: %s\n", *argv); 
        exit(1); 
      }
      argv++; argc--;
    }
  }

  // Return OK status 
  return 1;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x14(%rsp)
jne 0x125aa
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x125aa
leaq 0x120a68(%rip), %rdi    # 0x133004
movb $0x0, %al
callq 0xf070
xorl %edi, %edi
callq 0xf600
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x12703
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1268d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x120a4c(%rip), %rsi    # 0x13303d
callq 0xf700
cmpl $0x0, %eax
jne 0x12607
movl $0x1, 0x165f73(%rip)    # 0x178578
jmp 0x12672
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x120a2a(%rip), %rsi    # 0x133040
callq 0xf700
cmpl $0x0, %eax
jne 0x12650
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf640
movsd %xmm0, 0x165f1a(%rip)   # 0x178568
jmp 0x12670
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x1209ec(%rip), %rdi    # 0x13304b
movb $0x0, %al
callq 0xd4820
movl $0x1, %edi
callq 0xf600
jmp 0x12672
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x126fe
cmpq $0x0, 0x165ecb(%rip)    # 0x178560
jne 0x126a8
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x165eba(%rip)    # 0x178560
jmp 0x126e5
cmpq $0x0, 0x165ec0(%rip)    # 0x178570
jne 0x126c3
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x165eaf(%rip)    # 0x178570
jmp 0x126e3
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x120979(%rip), %rdi    # 0x13304b
movb $0x0, %al
callq 0xd4820
movl $0x1, %edi
callq 0xf600
jmp 0x126e5
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x125c3
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/grd2msh/grd2msh.cpp
// Function: WriteMesh(gaps::R3Mesh*, char*)
static int
WriteMesh(R3Mesh *mesh, char *mesh_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Write mesh to file
  if (!mesh->WriteFile(mesh_name)) return 0;

  // Print statistics
  if (print_verbose) {
    printf("Wrote mesh ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rsp, %rdi
callq 0xd0600
movq %rsp, %rdi
callq 0x13070
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
cmpl $0x0, %eax
jne 0x12fc3
movl $0x0, 0x24(%rsp)
jmp 0x13059
cmpl $0x0, 0x1655ae(%rip)    # 0x178578
je 0x13051
leaq 0x120213(%rip), %rdi    # 0x1331ea
movb $0x0, %al
callq 0xf070
movq %rsp, %rdi
callq 0xd06c0
leaq 0x1200c0(%rip), %rdi    # 0x1330ad
movb $0x1, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x13330
movl %eax, %esi
leaq 0x1201b0(%rip), %rdi    # 0x1331b7
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x13350
movl %eax, %esi
leaq 0x1201a6(%rip), %rdi    # 0x1331c7
movb $0x0, %al
callq 0xf070
movq 0x18(%rsp), %rdi
callq 0x13370
movl %eax, %esi
leaq 0x12019c(%rip), %rdi    # 0x1331d7
movb $0x0, %al
callq 0xf070
movq 0x15bf47(%rip), %rax    # 0x16ef90
movq (%rax), %rdi
callq 0xf5d0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yeonnic[P]solparser/./main.cpp
// Function: ReadFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string ReadFile(const string &fileName){
  ifstream f(fileName);
  string s;

  if(f.is_open()){
    f.seekg(0, ios::end);

    size_t size = f.tellg();

    s.resize(size);

    f.seekg(0, ios::beg);

    f.read(&s[0], size);
  } else {
    cout << "file open error!" << endl;
    exit(-1);
  }

  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x260(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movl $0x8, %edx
callq 0x6590
movq -0x260(%rbp), %rdi
movb $0x0, -0x219(%rbp)
callq 0x6510
movq -0x258(%rbp), %rdi
callq 0x6580
movb %al, -0x249(%rbp)
jmp 0x68d7
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x68e6
jmp 0x69e2
xorl %eax, %eax
movl %eax, %esi
leaq -0x218(%rbp), %rdi
movl $0x2, %edx
callq 0x64c0
jmp 0x68fd
leaq -0x218(%rbp), %rdi
callq 0x6610
movq %rdx, -0x278(%rbp)
movq %rax, -0x270(%rbp)
jmp 0x6919
movq -0x278(%rbp), %rax
movq -0x270(%rbp), %rcx
movq %rcx, -0x248(%rbp)
movq %rax, -0x240(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x7d50
movq %rax, -0x280(%rbp)
jmp 0x694a
movq -0x260(%rbp), %rdi
movq -0x280(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rsi
callq 0x6500
jmp 0x696d
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x64c0
jmp 0x697f
movq -0x260(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6690
movq %rax, -0x288(%rbp)
jmp 0x6998
movq -0x288(%rbp), %rsi
movq -0x238(%rbp), %rdx
leaq -0x218(%rbp), %rdi
callq 0x6430
jmp 0x69b4
jmp 0x6a1d
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
callq 0x61f0
leaq -0x218(%rbp), %rdi
callq 0x60d0
jmp 0x6a55
movq 0x465e7(%rip), %rdi     # 0x4cfd0
leaq 0x30678(%rip), %rsi     # 0x37068
callq 0x6320
movq %rax, -0x290(%rbp)
jmp 0x69fe
movq -0x290(%rbp), %rdi
movq 0x465b4(%rip), %rsi     # 0x4cfc0
callq 0x6360
jmp 0x6a13
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x63e0
movb $0x1, -0x219(%rbp)
testb $0x1, -0x219(%rbp)
jne 0x6a39
movq -0x260(%rbp), %rdi
callq 0x61f0
leaq -0x218(%rbp), %rdi
callq 0x60d0
movq -0x268(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/./main.cpp
// Function: TokensView(std::vector<Token, std::allocator<Token>> const&)
void TokensView(const vector<Token> &T){
  cout << "[ ";
  for ( auto i: T){
    cout << "'\x1b[91m" << i.str << "\x1b[0m', ";
  }
  cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq 0x4650d(%rip), %rdi     # 0x4cfd0
leaq 0x305b1(%rip), %rsi     # 0x3707b
callq 0x6320
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7d70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7da0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7dd0
testb $0x1, %al
jne 0x6b04
jmp 0x6b82
leaq -0x18(%rbp), %rdi
callq 0x7e10
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x7e30
movq 0x464b0(%rip), %rdi     # 0x4cfd0
leaq 0x30557(%rip), %rsi     # 0x3707e
callq 0x6320
movq %rax, -0x60(%rbp)
jmp 0x6b32
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x62d0
movq %rax, -0x68(%rbp)
jmp 0x6b45
movq -0x68(%rbp), %rdi
leaq 0x30535(%rip), %rsi     # 0x37085
callq 0x6320
jmp 0x6b57
leaq -0x48(%rbp), %rdi
callq 0x7e70
leaq -0x18(%rbp), %rdi
callq 0x7e90
jmp 0x6af1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7e70
jmp 0x6baa
movq 0x46447(%rip), %rdi     # 0x4cfd0
leaq 0x304fd(%rip), %rsi     # 0x3708d
callq 0x6320
movq %rax, %rdi
movq 0x46421(%rip), %rsi     # 0x4cfc0
callq 0x6360
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/./main.cpp
// Function: SoltreeView(SolTree const&, int)
void SoltreeView(const SolTree &tree, int count = 0){
  printTab(count);
  cout << tree.name << " ";
  cout << "\n";
  if(tree.inherited.size()){
    cout << " is ";
    for(auto i : tree.inherited){
      cout << i.name << " ";
    }
  }
  for(auto i : tree.children){
    SoltreeView(i, count+1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x6a70
movq -0x8(%rbp), %rsi
movq 0x463eb(%rip), %rdi     # 0x4cfd0
callq 0x62d0
movq %rax, %rdi
leaq 0x30497(%rip), %rsi     # 0x3708b
callq 0x6320
movq 0x463d0(%rip), %rdi     # 0x4cfd0
leaq 0x308dd(%rip), %rsi     # 0x374e4
callq 0x6320
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x7eb0
cmpq $0x0, %rax
je 0x6cfe
movq 0x463a6(%rip), %rdi     # 0x4cfd0
leaq 0x3045e(%rip), %rsi     # 0x3708f
callq 0x6320
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7ee0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7f10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7f40
testb $0x1, %al
jne 0x6c72
jmp 0x6cfc
leaq -0x20(%rbp), %rdi
callq 0x7f80
movq %rax, %rsi
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x7fa0
movq -0x1a0(%rbp), %rsi
movq 0x46331(%rip), %rdi     # 0x4cfd0
callq 0x62d0
movq %rax, -0x198(%rbp)
jmp 0x6cad
movq -0x198(%rbp), %rdi
leaq 0x303d0(%rip), %rsi     # 0x3708b
callq 0x6320
jmp 0x6cc2
leaq -0xc8(%rbp), %rdi
callq 0x80e0
leaq -0x20(%rbp), %rdi
callq 0x8150
jmp 0x6c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x80e0
jmp 0x6dc4
jmp 0x6cfe
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x7ee0
movq %rax, -0xe8(%rbp)
movq -0xe0(%rbp), %rdi
callq 0x7f10
movq %rax, -0xf0(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x7f40
testb $0x1, %al
jne 0x6d4c
jmp 0x6dbb
leaq -0xe8(%rbp), %rdi
callq 0x7f80
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x7fa0
movq -0x1a8(%rbp), %rdi
movl -0xc(%rbp), %esi
incl %esi
callq 0x6bc0
jmp 0x6d81
leaq -0x190(%rbp), %rdi
callq 0x80e0
leaq -0xe8(%rbp), %rdi
callq 0x8150
jmp 0x6d33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x80e0
jmp 0x6dc4
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x6620
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::ArgumentParser::ParseCLI(int, char const* const*)
bool ParseCLI(const int argc, const char * const * argv)
            {
                if (Prog().empty())
                {
                    Prog(argv[0]);
                }
                const std::vector<std::string> args(argv + 1, argv + argc);
                return ParseArgs(args) == std::end(args);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x22ed0
movq %rax, %rdi
callq 0x65c0
testb $0x1, %al
jne 0x8a27
jmp 0x8ab5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6630
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x64f0
jmp 0x8a5e
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22ef0
jmp 0x8a70
leaq -0x38(%rbp), %rdi
callq 0x61f0
leaq -0x39(%rbp), %rdi
callq 0x6390
jmp 0x8ab5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8aa7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x61f0
leaq -0x39(%rbp), %rdi
callq 0x6390
jmp 0x8ba9
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xb0(%rbp)
movslq -0xc(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1c7b0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xa0(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0x22f30
jmp 0x8b06
leaq -0x69(%rbp), %rdi
callq 0x1c830
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x22ff0
movq %rax, -0xb8(%rbp)
jmp 0x8b28
movq -0xb8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x23050
movq %rax, -0xc0(%rbp)
jmp 0x8b45
movq -0xc0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x22fb0
movb %al, -0xc1(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x13c70
movb -0xc1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x1c830
jmp 0x8ba9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x13c70
movq -0x48(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::ArgumentParser::LongSeparator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void LongSeparator(const std::string &longseparator_)
            {
                if (longseparator_.empty())
                {
                    const std::string errorMessage("longseparator can not be set to empty");
#ifdef ARGS_NOEXCEPT
                    error = Error::Usage;
                    errorMsg = errorMessage;
#else
                    throw UsageError(errorMessage);
#endif
                } else
                {
                    this->longseparator = longseparator_;
                    this->helpParams.longSeparator = allowJoinedLongValue ? longseparator_ : " ";
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65c0
testb $0x1, %al
jne 0x9ead
jmp 0x9f68
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6630
movq -0x80(%rbp), %rdx
leaq 0x2d314(%rip), %rsi     # 0x371d9
leaq -0x30(%rbp), %rdi
callq 0x64f0
jmp 0x9ed0
leaq -0x31(%rbp), %rdi
callq 0x6390
movl $0x10, %edi
callq 0x61a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x157a0
jmp 0x9efb
movq -0x88(%rbp), %rdi
leaq 0x4275f(%rip), %rsi     # 0x4c668
leaq 0xb8d0(%rip), %rdx      # 0x157e0
callq 0x65e0
jmp 0xa046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6390
jmp 0xa03d
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x6270
jmp 0x9f5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x61f0
jmp 0xa03d
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0x6050
movq -0x78(%rbp), %rax
movb 0x1f9(%rax), %al
movb $0x0, -0x6a(%rbp)
testb $0x1, %al
je 0x9f9d
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x6150
jmp 0x9fcc
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6630
movq -0x90(%rbp), %rdx
movb $0x1, -0x6a(%rbp)
leaq 0x2d0cc(%rip), %rsi     # 0x3708b
leaq -0x68(%rbp), %rdi
callq 0x64f0
jmp 0x9fca
jmp 0x9fcc
movq -0x78(%rbp), %rdi
addq $0x298, %rdi            # imm = 0x298
leaq -0x68(%rbp), %rsi
callq 0x6050
jmp 0x9fe2
leaq -0x68(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x6a(%rbp)
jne 0x9ff3
jmp 0x9ffc
leaq -0x69(%rbp), %rdi
callq 0x6390
jmp 0xa034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa021
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x6a(%rbp)
jne 0xa029
jmp 0xa032
leaq -0x69(%rbp), %rdi
callq 0x6390
jmp 0xa03d
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::ArgumentParser::SetArgumentSeparations(bool, bool, bool, bool)
void SetArgumentSeparations(
                const bool allowJoinedShortValue_,
                const bool allowJoinedLongValue_,
                const bool allowSeparateShortValue_,
                const bool allowSeparateLongValue_)
            {
                this->allowJoinedShortValue = allowJoinedShortValue_;
                this->allowJoinedLongValue = allowJoinedLongValue_;
                this->allowSeparateShortValue = allowSeparateShortValue_;
                this->allowSeparateLongValue = allowSeparateLongValue_;

                this->helpParams.longSeparator = allowJoinedLongValue ? longseparator : " ";
                this->helpParams.shortSeparator = allowJoinedShortValue ? "" : " ";
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %sil
movb %sil, -0x9(%rbp)
andb $0x1, %dl
movb %dl, -0xa(%rbp)
andb $0x1, %cl
movb %cl, -0xb(%rbp)
andb $0x1, %al
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f8(%rax)
movb -0xa(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1f9(%rax)
movb -0xb(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1fa(%rax)
movb -0xc(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x1fb(%rax)
movb 0x1f9(%rax), %al
movb $0x0, -0x32(%rbp)
testb $0x1, %al
je 0xa104
movq -0x50(%rbp), %rsi
addq $0x1b8, %rsi            # imm = 0x1B8
leaq -0x30(%rbp), %rdi
callq 0x6150
jmp 0xa12d
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6630
movq -0x58(%rbp), %rdx
movb $0x1, -0x32(%rbp)
leaq 0x2cf6b(%rip), %rsi     # 0x3708b
leaq -0x30(%rbp), %rdi
callq 0x64f0
jmp 0xa12b
jmp 0xa12d
movq -0x50(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
addq $0x88, %rdi
leaq -0x30(%rbp), %rsi
callq 0x63f0
leaq -0x30(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x32(%rbp)
jne 0xa159
jmp 0xa162
leaq -0x31(%rbp), %rdi
callq 0x6390
movq -0x50(%rbp), %rdi
movb 0x1f8(%rdi), %cl
leaq 0x2cf18(%rip), %rsi     # 0x3708b
leaq 0x2cf00(%rip), %rax     # 0x3707a
testb $0x1, %cl
cmovneq %rax, %rsi
addq $0x210, %rdi            # imm = 0x210
addq $0x68, %rdi
callq 0x64d0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x32(%rbp)
jne 0xa1ab
jmp 0xa1b4
leaq -0x31(%rbp), %rdi
callq 0x6390
jmp 0xa1b6
movq -0x40(%rbp), %rdi
callq 0x6620
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::GetCommands()
virtual std::vector<Command*> GetCommands() override
            {
                if (selectedCommand != nullptr)
                {
                    return selectedCommand->GetCommands();
                }

                if (Matched())
                {
                    return Group::GetCommands();
                }

                return { this };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x130(%rax)
je 0xae84
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x130(%rax), %rsi
movq (%rsi), %rax
callq *0x28(%rax)
jmp 0xaf01
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0xae94
jmp 0xaea3
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0xbe50
jmp 0xaf01
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x190a0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x190c0
jmp 0xaedf
leaq -0x29(%rbp), %rdi
callq 0x19140
jmp 0xaf01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x19140
jmp 0xaf0b
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                if (selectedCommand != nullptr)
                {
                    if (auto *res = selectedCommand->Match(flag))
                    {
                        return res;
                    }

                    for (auto *child: Children())
                    {
                        if ((child->GetOptions() & Options::Global) != Options::None)
                        {
                            if (auto *res = child->Match(flag))
                            {
                                return res;
                            }
                        }
                    }

                    return nullptr;
                }

                if (subparser != nullptr)
                {
                    return subparser->Match(flag);
                }

                return Matched() ? Group::Match(flag) : nullptr;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, 0x130(%rax)
je 0xb023
movq -0x50(%rbp), %rax
movq 0x130(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xaf83
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb07f
movq -0x50(%rbp), %rdi
callq 0xdc60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdc80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xafbd
jmp 0xb019
leaq -0x30(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xde40
movl %eax, %edi
movl $0x10, %esi
callq 0xde20
cmpl $0x0, %eax
je 0xb00c
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xb00a
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb07f
jmp 0xb00c
jmp 0xb00e
leaq -0x30(%rbp), %rdi
callq 0xdd40
jmp 0xafaa
movq $0x0, -0x8(%rbp)
jmp 0xb07f
movq -0x50(%rbp), %rax
cmpq $0x0, 0x170(%rax)
je 0xb04c
movq -0x50(%rbp), %rax
movq 0x170(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x8(%rbp)
jmp 0xb07f
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0xb05c
jmp 0xb06f
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc010
movq %rax, -0x58(%rbp)
jmp 0xb077
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xb077
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::GetNextPositional()
virtual PositionalBase *GetNextPositional() override
            {
                if (selectedCommand != nullptr)
                {
                    if (auto *res = selectedCommand->GetNextPositional())
                    {
                        return res;
                    }

                    for (auto *child: Children())
                    {
                        if ((child->GetOptions() & Options::Global) != Options::None)
                        {
                            if (auto *res = child->GetNextPositional())
                            {
                                return res;
                            }
                        }
                    }

                    return nullptr;
                }

                if (subparser != nullptr)
                {
                    return subparser->GetNextPositional();
                }

                return Matched() ? Group::GetNextPositional() : nullptr;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x130(%rax)
je 0xb177
movq -0x48(%rbp), %rax
movq 0x130(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb0db
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb1cb
movq -0x48(%rbp), %rdi
callq 0xdc60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdc80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xb115
jmp 0xb16d
leaq -0x28(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xde40
movl %eax, %edi
movl $0x10, %esi
callq 0xde20
cmpl $0x0, %eax
je 0xb160
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xb15e
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb1cb
jmp 0xb160
jmp 0xb162
leaq -0x28(%rbp), %rdi
callq 0xdd40
jmp 0xb102
movq $0x0, -0x8(%rbp)
jmp 0xb1cb
movq -0x48(%rbp), %rax
cmpq $0x0, 0x170(%rax)
je 0xb19c
movq -0x48(%rbp), %rax
movq 0x170(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x8(%rbp)
jmp 0xb1cb
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0xb1ac
jmp 0xb1bb
movq -0x48(%rbp), %rdi
callq 0xc0b0
movq %rax, -0x50(%rbp)
jmp 0xb1c3
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xb1c3
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::Reset()
virtual void Reset() noexcept override
            {
                Group::Reset();
                selectedCommand = nullptr;
                subparserProgramLine.clear();
                subparserDescription.clear();
                subparserHasFlag = false;
                subparserHasPositional = false;
                subparserHasCommand = false;
#ifdef ARGS_NOEXCEPT
                subparserError = Error::None;
#endif
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xc5f0
movq -0x10(%rbp), %rdi
movq $0x0, 0x130(%rdi)
addq $0x150, %rdi            # imm = 0x150
callq 0x15660
movq -0x10(%rbp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x15680
movq -0x10(%rbp), %rax
movb $0x0, 0x168(%rax)
movb $0x0, 0x169(%rax)
movb $0x0, 0x16a(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::GetCommands()
virtual std::vector<Command*> GetCommands() override
            {
                std::vector<Command*> res;
                for (const auto &child : Children())
                {
                    auto subparsers = child->GetCommands();
                    res.insert(std::end(res), std::begin(subparsers), std::end(subparsers));
                }
                return res;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd7e0
movq -0x90(%rbp), %rdi
callq 0xdc60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdc80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xbec8
jmp 0xbfbd
leaq -0x28(%rbp), %rdi
callq 0xdd20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0xbeeb
movq -0xa0(%rbp), %rdi
callq 0xffb0
movq %rax, -0xa8(%rbp)
jmp 0xbf00
movq -0xa8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xffe0
leaq -0x50(%rbp), %rdi
callq 0x10020
movq %rax, -0xb0(%rbp)
jmp 0xbf2a
movq -0xb0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xffb0
movq %rax, -0xb8(%rbp)
jmp 0xbf47
movq -0xa0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0xff00
movq %rax, -0xc0(%rbp)
jmp 0xbf73
movq -0xc0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10050
leaq -0x28(%rbp), %rdi
callq 0xdd40
jmp 0xbeb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xbfe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10050
jmp 0xbfe3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xbfd3
movq -0xa0(%rbp), %rdi
callq 0x10050
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x10050
movq -0x58(%rbp), %rdi
callq 0x6620
nopl (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                for (Base *child: Children())
                {
                    if (FlagBase *match = child->Match(flag))
                    {
                        return match;
                    }
                }
                return nullptr;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdc80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xc05a
jmp 0xc09a
leaq -0x28(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xc08d
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc0a2
jmp 0xc08f
leaq -0x28(%rbp), %rdi
callq 0xdd40
jmp 0xc047
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::GetNextPositional()
virtual PositionalBase *GetNextPositional() override
            {
                for (Base *child: Children())
                {
                    if (auto next = child->GetNextPositional())
                    {
                        return next;
                    }
                }
                return nullptr;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdc80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xc0f6
jmp 0xc132
leaq -0x20(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xc125
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc13a
jmp 0xc127
leaq -0x20(%rbp), %rdi
callq 0xdd40
jmp 0xc0e3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::GetAllFlags()
virtual std::vector<FlagBase*> GetAllFlags() override
            {
                std::vector<FlagBase*> res;
                for (Base *child: Children())
                {
                    auto childRes = child->GetAllFlags();
                    res.insert(res.end(), childRes.begin(), childRes.end());
                }
                return res;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xd860
movq -0x90(%rbp), %rdi
callq 0xdc60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdc80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xc1c8
jmp 0xc297
leaq -0x28(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0xc1eb
movq -0xa0(%rbp), %rdi
callq 0x11820
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x11850
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x11890
movq -0xb0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x11820
movq -0xa0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x11770
movq %rax, -0xa8(%rbp)
jmp 0xc24d
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x118c0
leaq -0x28(%rbp), %rdi
callq 0xdd40
jmp 0xc1b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xc2bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x118c0
jmp 0xc2bd
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc2ad
movq -0xa0(%rbp), %rdi
callq 0x118c0
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x118c0
movq -0x58(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::GetProgramLine[abi:cxx11](args::HelpParams const&) const
virtual std::vector<std::string> GetProgramLine(const HelpParams &params) const override
            {
                std::vector <std::string> names;
                for (Base *child: Children())
                {
                    if ((child->GetOptions() & Options::HiddenFromUsage) != Options::None)
                    {
                        continue;
                    }

                    auto groupNames = child->GetProgramLine(params);
                    names.insert(
                        std::end(names),
                        std::make_move_iterator(std::begin(groupNames)),
                        std::make_move_iterator(std::end(groupNames)));
                }
                return names;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xb7d0
movq -0xa8(%rbp), %rdi
callq 0xdc60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdc80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xc44c
jmp 0xc5b0
leaq -0x30(%rbp), %rdi
callq 0xdd20
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xde40
movl %eax, %edi
movl $0x4, %esi
callq 0xde20
cmpl $0x0, %eax
je 0xc47b
jmp 0xc57d
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x68(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xc492
movq -0xb8(%rbp), %rdi
callq 0x13ba0
movq %rax, -0xc0(%rbp)
jmp 0xc4a7
movq -0xc0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x13bd0
leaq -0x58(%rbp), %rdi
callq 0x13c40
movq %rax, -0xc8(%rbp)
jmp 0xc4d1
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rdi
callq 0x13c10
movq %rax, -0xd0(%rbp)
jmp 0xc4f4
movq -0xd0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x13ba0
movq %rax, -0xd8(%rbp)
jmp 0xc511
movq -0xd8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x13c10
movq %rax, -0xe0(%rbp)
jmp 0xc534
movq -0xb8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq 0x13af0
movq %rax, -0xe8(%rbp)
jmp 0xc566
movq -0xe8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x13c70
leaq -0x30(%rbp), %rdi
callq 0xdd40
jmp 0xc436
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc5d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x13c70
jmp 0xc5d6
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc5c6
movq -0xb8(%rbp), %rdi
callq 0x13c70
movq -0xb0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x13c70
movq -0x60(%rbp), %rdi
callq 0x6620
nopl (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Group::Reset()
virtual void Reset() noexcept override
            {
                Base::Reset();

                for (auto &child: Children())
                {
                    child->Reset();
                }
#ifdef ARGS_NOEXCEPT
                error = Error::None;
                errorMsg.clear();
#endif
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xca20
movq -0x30(%rbp), %rdi
callq 0xdc60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdcb0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xdce0
testb $0x1, %al
jne 0xc643
jmp 0xc668
leaq -0x18(%rbp), %rdi
callq 0xdd20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
leaq -0x18(%rbp), %rdi
callq 0xdd40
jmp 0xc630
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Base::GetDescription[abi:cxx11](args::HelpParams const&, unsigned int) const
virtual std::vector<std::tuple<std::string, std::string, unsigned>> GetDescription(const HelpParams &, const unsigned indentLevel) const
            {
                std::tuple<std::string, std::string, unsigned> description;
                std::get<1>(description) = help;
                std::get<2>(description) = indentLevel;
                return { std::move(description) };
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xca40
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdi
addq $0x10, %rax
movq %rax, -0xe0(%rbp)
callq 0xca70
movq -0xe0(%rbp), %rsi
movq %rax, %rdi
callq 0x6050
jmp 0xc785
movl -0x1c(%rbp), %eax
movl %eax, -0x11c(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xca90
movl -0x11c(%rbp), %ecx
movq -0x118(%rbp), %rsi
movl %ecx, (%rax)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0xcab0
movq -0x110(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x1, -0x80(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0xcae0
movq -0x100(%rbp), %rdi
movq -0x108(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0xcb00
jmp 0xc809
leaq -0xd1(%rbp), %rdi
callq 0xcb80
leaq -0xd0(%rbp), %rax
movq %rax, -0x130(%rbp)
addq $0x48, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
addq $-0x48, %rdi
movq %rdi, -0x138(%rbp)
callq 0xcba0
movq -0x130(%rbp), %rcx
movq -0x138(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x128(%rbp)
jne 0xc82e
leaq -0x68(%rbp), %rdi
callq 0xcba0
movq -0xf8(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xc8ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd1(%rbp), %rdi
callq 0xcb80
leaq -0xd0(%rbp), %rax
movq %rax, -0x148(%rbp)
addq $0x48, %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rdi
addq $-0x48, %rdi
movq %rdi, -0x150(%rbp)
callq 0xcba0
movq -0x148(%rbp), %rcx
movq -0x150(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x140(%rbp)
jne 0xc8b7
jmp 0xc8ea
leaq -0x68(%rbp), %rdi
callq 0xcba0
movq -0x70(%rbp), %rdi
callq 0x6620
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::UpdateSubparserHelp(args::HelpParams const&) const
void UpdateSubparserHelp(const HelpParams &params) const
            {
                if (parserCoroutine)
                {
                    RaiiSubparser coro(*this, params);
#ifndef ARGS_NOEXCEPT
                    try
                    {
                        parserCoroutine(coro.Parser());
                    }
                    catch (args::SubparserError&)
                    {
                    }
#else
                    parserCoroutine(coro.Parser());
#endif
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0x16380
testb $0x1, %al
jne 0x15983
jmp 0x15a4c
movq -0xf8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x163a0
movq -0xf8(%rbp), %rax
movq -0x110(%rbp), %rdi
addq $0x108, %rax            # imm = 0x108
movq %rax, -0x108(%rbp)
callq 0x16450
movq %rax, -0x100(%rbp)
jmp 0x159ca
movq -0x100(%rbp), %rsi
movq -0x108(%rbp), %rdi
callq 0x16410
jmp 0x159df
jmp 0x15a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x15a3e
movq -0xe0(%rbp), %rdi
callq 0x6130
movq %rax, -0xf0(%rbp)
callq 0x65b0
jmp 0x15a1c
jmp 0x15a1e
leaq -0xd8(%rbp), %rdi
callq 0x16470
jmp 0x15a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x16470
jmp 0x15a55
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)