LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: GetProperty(gaps::R3MeshPropertySet*, char const*)
R3MeshProperty
GetProperty(R3MeshPropertySet *properties, const char *name)
{
  // Initialize property
  R3MeshProperty property(properties->Mesh());

  // Find property in properties
  R3MeshProperty *existing_property = properties->Property(name);
  if (existing_property) return R3MeshProperty(*existing_property);

  // Read property from file
  R3MeshProperty new_property(properties->Mesh());
  if (new_property.Read(name)) return new_property;

  // Property not found
  RNFail("Unable to get property %s\n", name); 
  exit(-1); 
}

// Assembly:
subq $0x4a8, %rsp            # imm = 0x4A8
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x4a0(%rsp)
movq %rsi, 0x498(%rsp)
movq %rdx, 0x490(%rsp)
movq 0x498(%rsp), %rdi
callq 0x13470
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x48(%rsp), %rdi
movq %rcx, %rdx
callq 0x16a70
movq 0x498(%rsp), %rdi
movq 0x490(%rsp), %rsi
callq 0x13480
movq %rax, 0x20(%rsp)
jmp 0x10089
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x100cc
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x16c80
jmp 0x100ac
movl $0x1, 0x30(%rsp)
jmp 0x1017c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x10193
movb $0x0, 0x2f(%rsp)
movq 0x498(%rsp), %rdi
callq 0x13470
movq %rax, 0x8(%rsp)
jmp 0x100e5
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x16a70
jmp 0x100fd
movq 0x10(%rsp), %rdi
movq 0x490(%rsp), %rsi
callq 0x1aef0
movl %eax, 0x4(%rsp)
jmp 0x10115
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
je 0x1014e
movb $0x1, 0x2f(%rsp)
movl $0x1, 0x30(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x1017a
jmp 0x10170
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x16e00
jmp 0x10193
movq 0x490(%rsp), %rsi
leaq 0x94edb(%rip), %rdi     # 0xa5038
xorl %eax, %eax
callq 0xa4cd0
jmp 0x10166
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x10(%rsp), %rdi
callq 0x16e00
jmp 0x1017c
leaq 0x48(%rsp), %rdi
callq 0x16e00
movq 0x18(%rsp), %rax
addq $0x4a8, %rsp            # imm = 0x4A8
retq
leaq 0x48(%rsp), %rdi
callq 0x16e00
movq 0x38(%rsp), %rdi
callq 0xd6d0
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: ParseArgs(int, char**)
int ParseArgs(int argc, char **argv)
{
  // Parse arguments
  for (int i = 0; i < argc; i++) {
    if (!strcmp(argv[i], "-v")) print_verbose = 1; 
    else if (!strcmp(argv[i], "-debug")) print_debug = 1; 
    else if (!strcmp(argv[i], "-parameters_in_absolute_units")) parameters_in_relative_units = 0; 
    else if (!strcmp(argv[i], "-parameters_in_relative_units")) parameters_in_relative_units = 1; 
  }

  // Return OK status 
  return 1;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x10298
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x94e6b(%rip), %rsi     # 0xa5053
callq 0xd590
cmpl $0x0, %eax
jne 0x10201
movl $0x1, 0xbc9ec(%rip)     # 0xccbe8
jmp 0x10286
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x94e40(%rip), %rsi     # 0xa5056
callq 0xd590
cmpl $0x0, %eax
jne 0x1022c
movl $0x1, 0xbc9c2(%rip)     # 0xccbec
jmp 0x10284
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x94e1c(%rip), %rsi     # 0xa505d
callq 0xd590
cmpl $0x0, %eax
jne 0x10257
movl $0x0, 0xbc1ab(%rip)     # 0xcc400
jmp 0x10282
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x94e0f(%rip), %rsi     # 0xa507b
callq 0xd590
cmpl $0x0, %eax
jne 0x10280
movl $0x1, 0xbc180(%rip)     # 0xcc400
jmp 0x10282
jmp 0x10284
jmp 0x10286
jmp 0x10288
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x101c5
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: main
int main(int argc, char **argv)
{
  // Check program arguments
  if (argc < 4) { printf("Usage: prp2prp inputmesh inputprops outputprops [options]\n"); exit(-1); }
  input_mesh_name = argv[1];
  input_properties_name = argv[2];
  output_properties_name = argv[3];
  argc -=4; argv+=4;

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read mesh file
  R3Mesh *mesh = ReadMesh(input_mesh_name);
  if (!mesh) exit(-1);

  // Read properties file
  R3MeshPropertySet *properties = ReadProperties(mesh, input_properties_name);
  if (!properties) exit(-1);

  // Apply property processing operations
  if (!ApplyOperations(mesh, properties, argc, argv)) exit(-1);

  // Write properties file
  if (!WriteProperties(properties, output_properties_name)) exit(-1);

  // Return success 
  return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x4, 0x20(%rsp)
jge 0x102e4
leaq 0x94dc6(%rip), %rdi     # 0xa5099
movb $0x0, %al
callq 0xd070
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xbc8fc(%rip)     # 0xccbf0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbc8f4(%rip)     # 0xccbf8
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0xbc8ec(%rip)     # 0xccc00
movl 0x20(%rsp), %eax
subl $0x4, %eax
movl %eax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
callq 0x101b0
cmpl $0x0, %eax
jne 0x1034a
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0xbc89f(%rip), %rdi     # 0xccbf0
callq 0x103f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1036d
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x10(%rsp), %rdi
movq 0xbc87f(%rip), %rsi     # 0xccbf8
callq 0x10550
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x10395
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0x10840
cmpl $0x0, %eax
jne 0x103bc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x8(%rsp), %rdi
movq 0xbc838(%rip), %rsi     # 0xccc00
callq 0x10dc0
cmpl $0x0, %eax
jne 0x103dc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Merge(gaps::R3MeshPropertySet*, char const*, char const*)
static void
Merge(R3MeshPropertySet *properties, const char *filename, const char *property_name)
{
  // Read new property set
  R3MeshPropertySet *new_properties = ReadProperties(properties->Mesh(), filename);
  if (!new_properties) exit(-1);

  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(new_properties, property_name);

  // Apply operation to properties
  for (int i = 0; i < subset.NEntries(); i++) {
    R3MeshProperty *property = subset[i];
    properties->Insert(property);
  }

  // Delete new property set (does not delete properties)
  delete new_properties;

  // Print message
  if (print_debug) {
    printf("  Insert %s\n", filename);
    fflush(stdout);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
callq 0x13470
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x10550
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x11051
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xd510
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x11d60
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x135d0
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0x110e5
movl 0x34(%rsp), %esi
leaq 0x38(%rsp), %rdi
callq 0x13610
movq %rax, 0x10(%rsp)
jmp 0x1109e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x138e0
jmp 0x110bc
jmp 0x110be
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x1106d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13630
jmp 0x1114e
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1110e
movq 0x8(%rsp), %rdi
callq 0x13910
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0xd410
cmpl $0x0, 0xbbad7(%rip)     # 0xccbec
je 0x1113f
movq 0x58(%rsp), %rsi
leaq 0x941b2(%rip), %rdi     # 0xa52d5
xorl %eax, %eax
callq 0xd070
jmp 0x1112c
movq 0xbae6d(%rip), %rax     # 0xcbfa0
movq (%rax), %rdi
callq 0xd4e0
jmp 0x1113d
jmp 0x1113f
leaq 0x38(%rsp), %rdi
callq 0x13630
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd6d0
nopl (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Replace(gaps::R3MeshPropertySet*, char const*, char const*, int&, char**&)
static void
Replace(R3MeshPropertySet *properties, const char *property_name, const char *operation_name, int& argc, char **& argv) 
{
  // What a hack
  int save_argc = argc;
  char **save_argv = argv;

  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(properties, property_name);

  // Apply operation to properties
  for (int i = 0; i < subset.NEntries(); i++) {
    R3MeshProperty *property = subset[i];
    argc = save_argc; argv = save_argv;
    ApplyOperation(properties, property, operation_name, argc, argv, FALSE);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x58(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x11d60
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x135d0
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x1125a
movl 0x2c(%rsp), %esi
leaq 0x30(%rsp), %rdi
callq 0x13610
movq %rax, 0x8(%rsp)
jmp 0x111e6
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movl 0x4c(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, (%rax)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x70(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
xorl %r9d, %r9d
callq 0x12030
jmp 0x1122e
jmp 0x11230
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x111b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x13630
jmp 0x11269
leaq 0x30(%rsp), %rdi
callq 0x13630
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd6d0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Insert(gaps::R3MeshPropertySet*, char const*, char const*, int&, char**&)
static void
Insert(R3MeshPropertySet *properties, const char *property_name, const char *operation_name, int& argc, char **& argv)
{
  // What a hack
  int save_argc = argc;
  char **save_argv = argv;

  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(properties, property_name);

  // Insert copy and apply operation to properties
  for (int i = 0; i < subset.NEntries(); i++) {
    R3MeshProperty *property = subset[i];
    R3MeshProperty *copy = new R3MeshProperty(*property);
    argc = save_argc; argv = save_argv;
    ApplyOperation(properties, copy, operation_name, argc, argv);
    properties->Insert(copy);
  }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x11d60
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x135d0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x113da
movl 0x3c(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x13610
movq %rax, 0x8(%rsp)
jmp 0x1130f
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x448, %edi            # imm = 0x448
callq 0xd400
movq %rax, (%rsp)
jmp 0x1132c
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x16c80
jmp 0x1133c
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x5c(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, (%rax)
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %r8
movl $0x1, %r9d
callq 0x12030
jmp 0x11386
movq 0x80(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x138e0
jmp 0x1139a
jmp 0x1139c
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x112da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x113ec
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x448, %esi            # imm = 0x448
callq 0xd410
jmp 0x113ec
leaq 0x40(%rsp), %rdi
callq 0x13630
addq $0x88, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0x13630
movq 0x28(%rsp), %rdi
callq 0xd6d0
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Remove(gaps::R3MeshPropertySet*, char const*)
static void
Remove(R3MeshPropertySet *properties, const char *property_name)
{
  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(properties, property_name);

  // Remove properties
  for (int i = 0; i < subset.NEntries(); i++) {
    R3MeshProperty *property = subset[i];
    properties->Remove(property);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x11d60
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x135d0
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x11bc0
movl 0x24(%rsp), %esi
leaq 0x28(%rsp), %rdi
callq 0x13610
movq %rax, (%rsp)
jmp 0x11b7a
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x13c30
jmp 0x11b97
jmp 0x11b99
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x11b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13630
jmp 0x11bcf
leaq 0x28(%rsp), %rdi
callq 0x13630
addq $0x48, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0xd6d0
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Select(gaps::R3MeshPropertySet*, char const*)
static void
Select(R3MeshPropertySet *properties, const char *property_name)
{
  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(properties, property_name);

  // Reset properties to include only subset
  properties->Empty();
  for (int i = 0; i < subset.NEntries(); i++) {
    R3MeshProperty *property = subset[i];
    properties->Insert(property);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x11d60
movq 0x40(%rsp), %rdi
callq 0x13950
jmp 0x11c0e
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x135d0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x11c8c
movl 0x18(%rsp), %esi
leaq 0x28(%rsp), %rdi
callq 0x13610
movq %rax, (%rsp)
jmp 0x11c46
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x138e0
jmp 0x11c63
jmp 0x11c65
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x11c16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x13630
jmp 0x11c9b
leaq 0x28(%rsp), %rdi
callq 0x13630
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd6d0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Rename(gaps::R3MeshPropertySet*, char const*, char const*)
static void
Rename(R3MeshPropertySet *properties, const char *property_name, const char *new_property_name)
{
  // Find properties matching property_name
  RNArray<R3MeshProperty *> subset = FindProperties(properties, property_name);
  if (subset.NEntries() != 1) { RNFail("Unable to find unambiguous property %s\n", property_name); abort(); }
  subset[0]->SetName((char *) new_property_name);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x11d60
leaq 0x20(%rsp), %rdi
callq 0x135d0
cmpl $0x1, %eax
je 0x11d1a
movq 0x38(%rsp), %rsi
leaq 0x93783(%rip), %rdi     # 0xa5475
xorl %eax, %eax
callq 0xa4cd0
jmp 0x11cfb
callq 0xd230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x13630
jmp 0x11d50
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x13610
movq %rax, 0x8(%rsp)
jmp 0x11d2d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x19cc0
jmp 0x11d41
leaq 0x20(%rsp), %rdi
callq 0x13630
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xd6d0
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Test(gaps::R3MeshProperty*)
static void 
Test(R3MeshProperty *property)
{
  // For debugging, etc.
  R3Mesh *mesh = property->Mesh();
  for (int i = 0; i < mesh->NVertices(); i++) {
    RNScalar value = property->VertexValue(i);
    value = 0.5 + 0.5 * sin(10 * value);
    property->SetVertexValue(i, value);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x13720
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x135b0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x132aa
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x13730
movsd %xmm0, 0x8(%rsp)
movsd 0x91dc0(%rip), %xmm0    # 0xa5028
mulsd 0x8(%rsp), %xmm0
callq 0xd0f0
movsd 0x91da5(%rip), %xmm1    # 0xa5020
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movsd 0x8(%rsp), %xmm0
callq 0x199d0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x13230
addq $0x28, %rsp
retq
nop
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: IsNumber(char const*)
static int
IsNumber(const char *s)
{
  if (!strcmp(s, "keep") || !strcmp(s, "Keep")) return 1;
  if (*s == '\0') return 0;
  if (*s == '+') s++;
  if (*s == '\0') return 0;
  if (*s == '-') s++;
  if (*s == '\0') return 0;
  while (*s) {
    if (!isdigit(*s) && (*s != '.') && (*s != 'E')) return 0;
    s++;
  }
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x92171(%rip), %rsi     # 0xa5436
callq 0xd590
cmpl $0x0, %eax
je 0x132e5
movq 0x8(%rsp), %rdi
leaq 0x92184(%rip), %rsi     # 0xa545f
callq 0xd590
cmpl $0x0, %eax
jne 0x132f2
movl $0x1, 0x14(%rsp)
jmp 0x133cd
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1330c
movl $0x0, 0x14(%rsp)
jmp 0x133cd
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x13327
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x13341
movl $0x0, 0x14(%rsp)
jmp 0x133cd
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x1335c
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x13373
movl $0x0, 0x14(%rsp)
jmp 0x133cd
jmp 0x13375
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x133c5
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
callq 0xd380
cmpl $0x0, %eax
jne 0x133b5
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x133b5
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x45, %eax
je 0x133b5
movl $0x0, 0x14(%rsp)
jmp 0x133cd
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x13375
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/prp2prp/prp2prp.cpp
// Function: Scale(gaps::R3Mesh*)
static RNScalar
Scale(R3Mesh *mesh)
{
  // Check if absolute scale
  if (!parameters_in_relative_units) return 1.0;

  // Compute smallest sigma
  static RNScalar scale = 1;
  static R3Mesh *last_mesh = NULL;
  if (mesh != last_mesh) {
    RNLength length = sqrt(mesh->Area());
    if (length > 0) scale = 1.0 / length;
    last_mesh = mesh;
  }

  // Return scale
  return scale;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpl $0x0, 0xb9010(%rip)     # 0xcc400
jne 0x13402
movsd 0x91c36(%rip), %xmm0    # 0xa5030
movsd %xmm0, 0x10(%rsp)
jmp 0x13461
movq 0x8(%rsp), %rax
cmpq 0xb97fa(%rip), %rax     # 0xccc08
je 0x13453
movq 0x8(%rsp), %rdi
callq 0x1e910
callq 0xd300
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x13447
movsd 0x91bf6(%rip), %xmm0    # 0xa5030
divsd (%rsp), %xmm0
movsd %xmm0, 0xb8fc1(%rip)    # 0xcc408
movq 0x8(%rsp), %rax
movq %rax, 0xb97b5(%rip)     # 0xccc08
movsd 0xb8fad(%rip), %xmm0    # 0xcc408
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::parse()
void GoogleTTS::parse() {
    this->replace(_text);
    string cmd = _curl + _text + _lang + _client + "-H" + _ref + "-H";
    cmd += _agent + _out + " 2>/dev/null"; 
    _cmds.push_back(cmd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x128(%rbp)
movq %rdi, %rsi
addq $0x40, %rsi
movq %rsi, -0x130(%rbp)
callq 0x4ea0
movq -0x130(%rbp), %rdx
movq -0x128(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6510
movq -0x128(%rbp), %rdx
movq -0x120(%rbp), %rsi
addq $0x20, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x65e0
jmp 0x4a8e
movq -0x128(%rbp), %rdx
addq $0x60, %rdx
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x65e0
jmp 0x4aae
leaq 0x69b6(%rip), %rdx      # 0xb46b
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6590
jmp 0x4ac7
movq -0x128(%rbp), %rdx
addq $0xc0, %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x65e0
jmp 0x4ae4
leaq 0x6980(%rip), %rdx      # 0xb46b
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6590
jmp 0x4afa
leaq -0x48(%rbp), %rdi
callq 0x2140
leaq -0x68(%rbp), %rdi
callq 0x2140
leaq -0x88(%rbp), %rdi
callq 0x2140
leaq -0xa8(%rbp), %rdi
callq 0x2140
leaq -0xc8(%rbp), %rdi
callq 0x2140
movq -0x128(%rbp), %rdx
movq %rdx, %rsi
addq $0xe0, %rsi
subq $-0x80, %rdx
leaq -0x118(%rbp), %rdi
callq 0x6510
jmp 0x4b53
leaq 0x6914(%rip), %rdx      # 0xb46e
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x6590
jmp 0x4b6f
leaq -0x28(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x22d0
jmp 0x4b81
leaq -0xf8(%rbp), %rdi
callq 0x2140
leaq -0x118(%rbp), %rdi
callq 0x2140
movq -0x128(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
leaq -0x28(%rbp), %rsi
callq 0x6410
jmp 0x4bb2
leaq -0x28(%rbp), %rdi
callq 0x2140
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4c50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4c44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4c38
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4c2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2140
leaq -0x68(%rbp), %rdi
callq 0x2140
leaq -0x88(%rbp), %rdi
callq 0x2140
leaq -0xa8(%rbp), %rdi
callq 0x2140
leaq -0xc8(%rbp), %rdi
callq 0x2140
jmp 0x4cb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4cb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x4ca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x2140
leaq -0x118(%rbp), %rdi
callq 0x2140
leaq -0x28(%rbp), %rdi
callq 0x2140
movq -0xd0(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::execute()
void GoogleTTS::execute() {
    if (_cmds.size() == 1) {
        std::system(_cmds[0].c_str());
    } else {
        for(string cmd : _cmds) {
            std::system(cmd.c_str());
        }
        this->unite();
    }
    _mpv += _speed + _play;
    std::system(_mpv.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x1a0, %rdi            # imm = 0x1A0
callq 0x64d0
cmpq $0x1, %rax
jne 0x4d72
movq -0x78(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
xorl %eax, %eax
movl %eax, %esi
callq 0x64f0
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x21c0
jmp 0x4e10
movq -0x78(%rbp), %rax
addq $0x1a0, %rax            # imm = 0x1A0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6300
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6330
testb $0x1, %al
jne 0x4dad
jmp 0x4e07
leaq -0x18(%rbp), %rdi
callq 0x6370
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x20d0
movq -0x80(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x21c0
jmp 0x4dd9
leaq -0x40(%rbp), %rdi
callq 0x2140
leaq -0x18(%rbp), %rdi
callq 0x6480
jmp 0x4d9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2140
jmp 0x4e8d
movq -0x78(%rbp), %rdi
callq 0x4cd0
movq -0x78(%rbp), %rdx
movq %rdx, %rsi
addq $0x120, %rsi            # imm = 0x120
addq $0x140, %rdx            # imm = 0x140
leaq -0x70(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6510
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
addq $0x100, %rdi            # imm = 0x100
callq 0x22d0
jmp 0x4e4e
leaq -0x70(%rbp), %rdi
callq 0x2140
movq -0x78(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x20c0
movq %rax, %rdi
callq 0x21c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2140
movq -0x48(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void GoogleTTS::replace(string& text) {
    size_t start_pos = 0;
    while ((start_pos = text.find(" ", start_pos)) != string::npos) {
       text.replace(start_pos, 1, "%20");
       start_pos += 3; // Handles case where 'to' is a substring of 'from'
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x653e(%rip), %rsi      # 0xb405
callq 0x23b0
movq %rax, -0x18(%rbp)
cmpq $-0x1, %rax
je 0x4efd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
leaq 0x657d(%rip), %rcx      # 0xb467
callq 0x2130
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x4eb8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::help()
void GoogleTTS::help() {
    std::cout << "gtts: plays Google Text-to-Speech speech synthesis with " << 
        "help of Google Translate voice" << std::endl;
    std::cout << "Usage: gtts [language] \"[message]\" ([speed])" << std::endl;
    std::cout << "Example: gtts us \"hello world\" 1.5" << std::endl;
    std::cout << "standard speed is 1.0" << std::endl;
    std::cout << std::endl;
    std::cout << "Options:" << std::endl;    
    std::cout << "-h\t\tshows this help" << std::endl;
    std::cout << "-v\t\tshows program version" << std::endl;
    std::cout << "-l\t\tshows all available languages" << std::endl;
    std::cout << std::endl;
    std::cout << "To speak from text files use: gtts [lang] \"$(cat file.txt)\""
       " ([speed])" << std::endl;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xb0bd(%rip), %rdi      # 0xffd8
leaq 0x6559(%rip), %rsi      # 0xb47b
callq 0x21f0
movq %rax, %rdi
leaq 0x6583(%rip), %rsi      # 0xb4b4
callq 0x21f0
movq %rax, %rdi
movq 0xb088(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xb08c(%rip), %rdi      # 0xffd8
leaq 0x6580(%rip), %rsi      # 0xb4d3
callq 0x21f0
movq %rax, %rdi
movq 0xb066(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xb06a(%rip), %rdi      # 0xffd8
leaq 0x658b(%rip), %rsi      # 0xb500
callq 0x21f0
movq %rax, %rdi
movq 0xb044(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xb048(%rip), %rdi      # 0xffd8
leaq 0x658c(%rip), %rsi      # 0xb523
callq 0x21f0
movq %rax, %rdi
movq 0xb022(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xb026(%rip), %rdi      # 0xffd8
movq 0xb00f(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xb013(%rip), %rdi      # 0xffd8
leaq 0x656d(%rip), %rsi      # 0xb539
callq 0x21f0
movq %rax, %rdi
movq 0xafed(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xaff1(%rip), %rdi      # 0xffd8
leaq 0x6554(%rip), %rsi      # 0xb542
callq 0x21f0
movq %rax, %rdi
movq 0xafcb(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xafcf(%rip), %rdi      # 0xffd8
leaq 0x6546(%rip), %rsi      # 0xb556
callq 0x21f0
movq %rax, %rdi
movq 0xafa9(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xafad(%rip), %rdi      # 0xffd8
leaq 0x653e(%rip), %rsi      # 0xb570
callq 0x21f0
movq %rax, %rdi
movq 0xaf87(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xaf8b(%rip), %rdi      # 0xffd8
movq 0xaf74(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xaf78(%rip), %rdi      # 0xffd8
leaq 0x652b(%rip), %rsi      # 0xb592
callq 0x21f0
movq %rax, %rdi
movq 0xaf52(%rip), %rsi      # 0xffc8
callq 0x2230
movq 0xaf56(%rip), %rdi      # 0xffd8
movq 0xaf3f(%rip), %rsi      # 0xffc8
callq 0x2230
popq %rbp
retq
// File: Shadowsith[P]gtts/gtts.cpp
// Function: gtts::GoogleTTS::languages()
void GoogleTTS::languages() {
    std::cout << "Supported languages:" << std::endl;
    int counter = 0;
    for(std::pair<string, string> l : lang_codes) {
        std::cout << l.first  << "\t:\t"<< l.second << std::endl;
    }    
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0xaf36(%rip), %rdi      # 0xffd8
leaq 0x652f(%rip), %rsi      # 0xb5d8
callq 0x21f0
movq %rax, %rdi
movq 0xaf10(%rip), %rsi      # 0xffc8
callq 0x2230
movl $0x0, -0x4(%rbp)
leaq 0xb145(%rip), %rax      # 0x10210
movq %rax, -0x10(%rbp)
leaq 0xb13a(%rip), %rdi      # 0x10210
callq 0x6820
movq %rax, -0x18(%rbp)
leaq 0xb12a(%rip), %rdi      # 0x10210
callq 0x6850
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6880
testb $0x1, %al
jne 0x5105
jmp 0x51a9
leaq -0x18(%rbp), %rdi
callq 0x68b0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x68d0
movq -0x80(%rbp), %rsi
movq 0xaeaf(%rip), %rdi      # 0xffd8
callq 0x21e0
movq %rax, -0x78(%rbp)
jmp 0x5134
movq -0x78(%rbp), %rdi
leaq 0x64ae(%rip), %rsi      # 0xb5ed
callq 0x21f0
movq %rax, -0x88(%rbp)
jmp 0x514d
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21e0
movq %rax, -0x90(%rbp)
jmp 0x5166
movq -0x90(%rbp), %rdi
movq 0xae54(%rip), %rsi      # 0xffc8
callq 0x2230
jmp 0x517b
leaq -0x60(%rbp), %rdi
callq 0x6930
leaq -0x18(%rbp), %rdi
callq 0x6960
jmp 0x50ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6930
jmp 0x51c5
movq 0xae28(%rip), %rdi      # 0xffd8
movq 0xae11(%rip), %rsi      # 0xffc8
callq 0x2230
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2350
nop
// File: lukasz-wiecaszek[P]h264iframedecoder/./aud.hpp
// Function: ymn::h264::primary_pic_type_to_string(unsigned int)
constexpr static inline const char* primary_pic_type_to_string(uint32_t primary_pic_type)
{
    const char* str = "invalid 'primary_pic_type' value";

    switch (primary_pic_type) {
        case 0: str = "(I)"; break;
        case 1: str = "(I, P)"; break;
        case 2: str = "(I, P, B)"; break;
        case 3: str = "(SI)"; break;
        case 4: str = "(SI, SP)"; break;
        case 5: str = "(I, SI)"; break;
        case 6: str = "(I, SI, P, SP)"; break;
        case 7: str = "(I, SI, P, SP, B)"; break;
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21dd2(%rip), %rax     # 0x243ed
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x7, %rax
ja 0x26b6
movq -0x18(%rsp), %rax
leaq 0x209c5(%rip), %rcx     # 0x23004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21dbf(%rip), %rax     # 0x2440e
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21db5(%rip), %rax     # 0x24412
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21dae(%rip), %rax     # 0x24419
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21daa(%rip), %rax     # 0x24423
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21da1(%rip), %rax     # 0x24428
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21d9c(%rip), %rax     # 0x24431
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21d96(%rip), %rax     # 0x24439
movq %rax, -0x10(%rsp)
jmp 0x26b6
leaq 0x21d97(%rip), %rax     # 0x24448
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/./vui_parameters.hpp
// Function: ymn::h264::video_format_to_string(unsigned int)
constexpr static inline const char* video_format_to_string(uint32_t video_format)
{
    const char* str = "invalid 'video_format' value";

    if (video_format <= 7) {
        switch (video_format) {
            case 0: str = "component"; break;
            case 1: str = "pal"; break;
            case 2: str = "ntsc"; break;
            case 3: str = "secam"; break;
            case 4: str = "mac"; break;
            case 5: str = "unspecified video format"; break;
            default:
                str = "reserved";
                break;
        }
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21be4(%rip), %rax     # 0x2450f
movq %rax, -0x10(%rsp)
cmpl $0x7, -0x4(%rsp)
ja 0x29c1
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0x29b3
movq -0x18(%rsp), %rax
leaq 0x206ce(%rip), %rcx     # 0x23024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21fcb(%rip), %rax     # 0x24931
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21bb8(%rip), %rax     # 0x2452c
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21bae(%rip), %rax     # 0x24530
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21ba5(%rip), %rax     # 0x24535
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21b9d(%rip), %rax     # 0x2453b
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21b93(%rip), %rax     # 0x2453f
movq %rax, -0x10(%rsp)
jmp 0x29bf
leaq 0x21b4c(%rip), %rax     # 0x24506
movq %rax, -0x10(%rsp)
jmp 0x29c1
movq -0x10(%rsp), %rax
retq
nopw (%rax,%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/./sps.hpp
// Function: ymn::h264::chroma_format_idc_to_string(unsigned int)
constexpr static inline const char* chroma_format_idc_to_string(uint32_t chroma_format_idc)
{
    const char* str = "invalid 'chroma_format_idc' value";

    switch (chroma_format_idc) {
        case 0: str = "monochrome"; break;
        case 1: str = "4:2:0"; break;
        case 2: str = "4:2:2"; break;
        case 3: str = "4:4:4"; break;
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21b7d(%rip), %rax     # 0x24558
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x3, %rax
ja 0x2a3a
movq -0x18(%rsp), %rax
leaq 0x20641(%rip), %rcx     # 0x2303c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21b6f(%rip), %rax     # 0x2457a
movq %rax, -0x10(%rsp)
jmp 0x2a3a
leaq 0x21b6c(%rip), %rax     # 0x24585
movq %rax, -0x10(%rsp)
jmp 0x2a3a
leaq 0x21b64(%rip), %rax     # 0x2458b
movq %rax, -0x10(%rsp)
jmp 0x2a3a
leaq 0x21b5c(%rip), %rax     # 0x24591
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
// File: lukasz-wiecaszek[P]h264iframedecoder/./nal_unit_type.hpp
// Function: ymn::to_string(ymn::nal_unit_type_e)
constexpr static inline const char* to_string(nal_unit_type_e e)
{
    const char *str = "invalid 'nal_unit_type_e' value";

    switch (e) {
#define NAL_UNIT_TYPE(id, value) case nal_unit_type_e::id: str = #id; break;
            NAL_UNIT_TYPES
#undef NAL_UNIT_TYPE
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21bfa(%rip), %rax     # 0x249b5
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x1f, %rax
ja 0x2fe8
movq -0x18(%rsp), %rax
leaq 0x20325(%rip), %rcx     # 0x23104
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21be6(%rip), %rax     # 0x249d5
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21be1(%rip), %rax     # 0x249e1
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bec(%rip), %rax     # 0x249fd
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bf8(%rip), %rax     # 0x24a1a
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21c04(%rip), %rax     # 0x24a37
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21c10(%rip), %rax     # 0x24a54
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21c17(%rip), %rax     # 0x24a6c
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21c0a(%rip), %rax     # 0x24a70
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bfd(%rip), %rax     # 0x24a74
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bf0(%rip), %rax     # 0x24a78
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21be3(%rip), %rax     # 0x24a7c
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21be2(%rip), %rax     # 0x24a8c
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bdf(%rip), %rax     # 0x24a9a
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bda(%rip), %rax     # 0x24aa6
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bd7(%rip), %rax     # 0x24ab4
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bd6(%rip), %rax     # 0x24ac4
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bd0(%rip), %rax     # 0x24acf
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bc9(%rip), %rax     # 0x24ad9
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bc2(%rip), %rax     # 0x24ae3
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bbb(%rip), %rax     # 0x24aed
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bc8(%rip), %rax     # 0x24b0b
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bcd(%rip), %rax     # 0x24b21
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bc6(%rip), %rax     # 0x24b2b
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bc2(%rip), %rax     # 0x24b35
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bbe(%rip), %rax     # 0x24b3f
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bb7(%rip), %rax     # 0x24b46
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21bb0(%rip), %rax     # 0x24b4d
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21ba9(%rip), %rax     # 0x24b54
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21ba2(%rip), %rax     # 0x24b5b
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21b99(%rip), %rax     # 0x24b60
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21b90(%rip), %rax     # 0x24b65
movq %rax, -0x10(%rsp)
jmp 0x2fe8
leaq 0x21b8c(%rip), %rax     # 0x24b6f
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nop
// File: lukasz-wiecaszek[P]h264iframedecoder/./slice_type.hpp
// Function: ymn::h264::to_string(ymn::h264::slice_type_e)
constexpr static inline const char* to_string(slice_type_e e)
{
    const char* str = "invalid 'slice_type_e' value";

    switch (e) {
#define SLICE_TYPE(id, value) case slice_type_e::id: str = #id; break;
            SLICE_TYPES
#undef SLICE_TYPE
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21b7e(%rip), %rax     # 0x24b79
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x4, %rax
ja 0x3068
movq -0x18(%rsp), %rax
leaq 0x20169(%rip), %rcx     # 0x23184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x21b6c(%rip), %rax     # 0x24b97
movq %rax, -0x10(%rsp)
jmp 0x3068
leaq 0x219fc(%rip), %rax     # 0x24a35
movq %rax, -0x10(%rsp)
jmp 0x3068
leaq 0x21a27(%rip), %rax     # 0x24a6e
movq %rax, -0x10(%rsp)
jmp 0x3068
leaq 0x21b41(%rip), %rax     # 0x24b96
movq %rax, -0x10(%rsp)
jmp 0x3068
leaq 0x21b36(%rip), %rax     # 0x24b99
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nop
// File: lukasz-wiecaszek[P]h264iframedecoder/./h264_parser.hpp
// Function: ymn::to_string(ymn::h264_parser_container_e)
constexpr static inline const char* to_string(h264_parser_container_e e)
{
    const char *str = "invalid 'h264_parser_container_e' value";

    switch (e) {
#define H264_PARSER_CONTAINER(id) case h264_parser_container_e::id: str = #id; break;
            H264_PARSER_CONTAINERS
#undef H264_PARSER_CONTAINER
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x21458(%rip), %rax     # 0x24f93
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl %eax, -0x14(%rsp)
testl %eax, %eax
je 0x3b59
jmp 0x3b4e
movl -0x14(%rsp), %eax
subl $0x1, %eax
je 0x3b67
jmp 0x3b73
leaq 0x2145b(%rip), %rax     # 0x24fbb
movq %rax, -0x10(%rsp)
jmp 0x3b73
leaq 0x21452(%rip), %rax     # 0x24fc0
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/main.cpp
// Function: mpeg2ts_parser_feed(ymn::mpeg2ts_parser&, unsigned char const*, unsigned long)
static void mpeg2ts_parser_feed(ymn::mpeg2ts_parser& parser, const uint8_t* data, std::size_t count)
{
    std::size_t n_written;

    do {
        n_written = parser.write(data, count);
        if (0 == n_written) {
            parser.reset();
            continue;
        }

        if (n_written > count) {
            std::cerr << "error: parser swallowed more data then requested (this is really bad)" << std::endl;
            exit(EXIT_FAILURE);
        }

        mpeg2ts_parser_parse(parser);

        data += n_written;
        count -= n_written;
    } while (count > 0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x10da0
movq %rax, 0x8(%rsp)
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
jne 0x3bc1
movq 0x20(%rsp), %rdi
callq 0x10e10
jmp 0x3c24
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x3bf9
movq 0x2a41c(%rip), %rdi     # 0x2dff0
leaq 0x213ed(%rip), %rsi     # 0x24fc8
callq 0x2140
movq %rax, %rdi
movq 0x2a3be(%rip), %rsi     # 0x2dfa8
callq 0x2180
movl $0x1, %edi
callq 0x21d0
movq 0x20(%rsp), %rdi
callq 0x3ce0
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x3b93
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/main.cpp
// Function: mpeg2ts_parser_parse(ymn::mpeg2ts_parser&)
static void mpeg2ts_parser_parse(ymn::mpeg2ts_parser& parser)
{
    ymn::mpeg2ts_parser_status_e status;
    const uint8_t *tspacket;
    mpeg2ts_parser_user_data* mpeg2ts_user_data;
    ymn::mpeg2ts_pid received_pid;
    ymn::mpeg2ts_pid required_pid;

    mpeg2ts_user_data = static_cast<mpeg2ts_parser_user_data*>(parser.get_user_data());
    required_pid = mpeg2ts_user_data->pid;

    do {
        status = parser.parse();
        //std::cout << to_string(status) << std::endl;

        switch (status) {
            case ymn::mpeg2ts_parser_status_e::SYNC_GAINED:
                std::cout << to_string(status) << std::endl;
                break;

            case ymn::mpeg2ts_parser_status_e::SYNCHRONIZED:
                tspacket = parser.get_tspacket();
                received_pid = ymn::mpeg2ts_parser_get_pid(tspacket);
                if (received_pid == required_pid)
                    mpeg2ts_parser_handle_tspacket(parser, tspacket);
                break;

            case ymn::mpeg2ts_parser_status_e::SYNC_LOST:
                std::cout << to_string(status) << std::endl;
                break;

            case ymn::mpeg2ts_parser_status_e::NOT_SYNCHRONIZED:
                break;

            default:
                break;
       }
    } while (status != ymn::mpeg2ts_parser_status_e::NEED_BYTES);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x24(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x109e0
leaq 0x20(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x109e0
movq 0x40(%rsp), %rdi
callq 0x11080
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x110a0
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x3, %eax
ja 0x3e09
movq 0x10(%rsp), %rax
leaq 0x1f497(%rip), %rcx     # 0x231e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x3c(%rsp), %edi
callq 0x3e20
movq %rax, %rsi
movq 0x2a253(%rip), %rdi     # 0x2dfc0
callq 0x2140
movq %rax, %rdi
movq 0x2a22c(%rip), %rsi     # 0x2dfa8
callq 0x2180
jmp 0x3e0b
movq 0x40(%rsp), %rdi
callq 0x11110
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3eb0
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x24(%rsp), %rdi
callq 0x11160
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11160
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jne 0x3ddc
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3ef0
jmp 0x3e0b
movl 0x3c(%rsp), %edi
callq 0x3e20
movq %rax, %rsi
movq 0x2a1cf(%rip), %rdi     # 0x2dfc0
callq 0x2140
movq %rax, %rdi
movq 0x2a1a8(%rip), %rsi     # 0x2dfa8
callq 0x2180
jmp 0x3e0b
jmp 0x3e0b
jmp 0x3e0b
jmp 0x3e0d
cmpl $0x0, 0x3c(%rsp)
jne 0x3d21
addq $0x48, %rsp
retq
nopl (%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/./mpeg2ts_parser.hpp
// Function: ymn::to_string(ymn::mpeg2ts_parser_status_e)
constexpr static inline const char* to_string(mpeg2ts_parser_status_e e)
{
    const char *str = "invalid 'mpeg2ts_parser_status_e' value";

    switch (e) {
#define MPEG2TS_PARSER_STATUS(id) case mpeg2ts_parser_status_e::id: str = #id; break;
            MPEG2TS_PARSER_STATUSES
#undef MPEG2TS_PARSER_STATUS
    }

    return str;
}

// Assembly:
movl %edi, -0x4(%rsp)
leaq 0x211e3(%rip), %rax     # 0x2500e
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0x3ea6
movq -0x18(%rsp), %rax
leaq 0x1f3ad(%rip), %rcx     # 0x231f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x211db(%rip), %rax     # 0x25036
movq %rax, -0x10(%rsp)
jmp 0x3ea6
leaq 0x211d8(%rip), %rax     # 0x25041
movq %rax, -0x10(%rsp)
jmp 0x3ea6
leaq 0x211e4(%rip), %rax     # 0x2505b
movq %rax, -0x10(%rsp)
jmp 0x3ea6
leaq 0x211c8(%rip), %rax     # 0x2504d
movq %rax, -0x10(%rsp)
jmp 0x3ea6
leaq 0x211c4(%rip), %rax     # 0x25057
movq %rax, -0x10(%rsp)
jmp 0x3ea6
leaq 0x211c7(%rip), %rax     # 0x25068
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: lukasz-wiecaszek[P]h264iframedecoder/main.cpp
// Function: mpeg2ts_parser_handle_tspacket(ymn::mpeg2ts_parser&, unsigned char const*)
static void mpeg2ts_parser_handle_tspacket(ymn::mpeg2ts_parser& parser, const uint8_t *tspacket)
{
    unsigned int adaptation_field_control;
    unsigned int payload_offset; // offset to the first byte in the payload or 0 if payload is not present
    unsigned int payload_unit_start_indicator;

    adaptation_field_control = (tspacket[3] >> 4) & 0x03;

    // 00 - reserved for future use by ISO/IEC
    // ITU-T Rec. H.222.0 | ISO/IEC 13818-1 decoders shall discard Transport Stream packets
    // with the adaptation_field_control field set to a value of '00'.
    // 01 - no adaptation_field, payload only
    // 10 - adaptation_field only, no payload
    // 11 - adaptation_field followed by payload
    switch (adaptation_field_control) {
        case  0: payload_offset = 0; break;
        case  1: payload_offset = 4; break;
        case  2: payload_offset = 0; break;
        case  3: payload_offset = 5 + tspacket[4]; break;
        default: payload_offset = 0; break;
    }

    if (payload_offset) {
        payload_unit_start_indicator = tspacket[1] & 0x40;
        mpeg2ts_parser_demux(
            parser,
            tspacket + payload_offset,
            MPEG2TS_PARSER_PACKET_SIZE - payload_offset,
            payload_unit_start_indicator);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x3(%rax), %eax
shrl $0x4, %eax
andl $0x3, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x3f63
movq (%rsp), %rax
leaq 0x1f2e6(%rip), %rcx     # 0x23210
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x10(%rsp)
jmp 0x3f6b
movl $0x4, 0x10(%rsp)
jmp 0x3f6b
movl $0x0, 0x10(%rsp)
jmp 0x3f6b
movq 0x18(%rsp), %rax
movzbl 0x4(%rax), %eax
addl $0x5, %eax
movl %eax, 0x10(%rsp)
jmp 0x3f6b
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x3fb3
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
andl $0x40, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x10(%rsp), %eax
addq %rax, %rsi
movl $0xbc, %eax
subl 0x10(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
cmpl $0x0, 0xc(%rsp)
setne %al
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x3fc0
addq $0x28, %rsp
retq
nopl (%rax,%rax)