LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::identify(int, sg::identity&)
int
  identify(const int     fd,
           sg::identity &ident)
  {
    int rv;
    int timeout;
    char buf[512];
    int buflen = sizeof(buf);
    struct ata_tf tf;

    tf_init(&tf,ATA_OP_IDENTIFY,0,1);

    timeout = 60000;
    rv = exec(fd,SG_READ,SG_PIO,&tf,buf,buflen,timeout);
    if(rv == 0)
      buf_to_identity(buf,ident);

    return rv;
  }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x7(%rcx)
movw $0xece0, (%rcx)         # imm = 0xECE0
movb $0x0, 0x7(%rcx)
movw $0x0, 0x8(%rcx)
movb $0x1, 0x6(%rcx)
movl $0xea60, (%rsp)         # imm = 0xEA60
leaq 0x20(%rsp), %r8
xorl %esi, %esi
xorl %edx, %edx
movl $0x200, %r9d            # imm = 0x200
callq 0x14814
movl %eax, %ebp
testl %eax, %eax
jne 0x14e3c
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x14aec
movl %ebp, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::read_block(int, unsigned long, unsigned long, void*, unsigned long, int)
int
  read_block(const int       fd_,
             const uint64_t  lba_,
             const uint64_t  blocks_,
             void           *buf_,
             const size_t    buflen_,
             const int       timeout_)
  {
    int blocks;
    int instruction;
    struct ata_tf tf;

    blocks = blocks_;
    if(blocks >= 65536)
      blocks = 0;
    instruction = ATA_OP_READ_PIO_EXT;
    tf_init(&tf,instruction,lba_,blocks);

    return exec(fd_,SG_READ,SG_PIO,&tf,buf_,buflen_,timeout_);
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %r8, %rax
movq %rcx, %r8
movq %rsi, %rbx
xorl %esi, %esi
cmpl $0x10000, %edx          # imm = 0x10000
cmovgel %esi, %edx
leaq 0x10(%rsp), %rcx
movq %rsi, (%rcx)
movq %rsi, 0x7(%rcx)
movw $0x24e0, (%rcx)         # imm = 0x24E0
movb %bl, 0x7(%rcx)
movb %bh, 0x18(%rsp)
movl %ebx, %esi
shrl $0x10, %esi
movb %sil, 0x9(%rcx)
movb %dl, 0x6(%rcx)
movb $0x1, 0x4(%rcx)
movb $0x0, 0xa(%rcx)
movb %dh, 0x1b(%rsp)
movl %ebx, %edx
shrl $0x18, %edx
movb %dl, 0xc(%rcx)
movq %rbx, %rdx
shrq $0x20, %rdx
movb %dl, 0xd(%rcx)
shrq $0x28, %rbx
movb %bl, 0xe(%rcx)
movl %r9d, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
movl %eax, %r9d
callq 0x14814
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::write_block(int, unsigned long, unsigned long, void const*, unsigned long, int)
int
  write_block(const int       fd_,
              const uint64_t  lba_,
              const uint64_t  blocks_,
              const void     *buf_,
              const size_t    buflen_,
              const int       timeout_)
  {
    int blocks;
    int instruction;
    struct ata_tf tf;

    blocks = blocks_;
    if(blocks >= 65536)
      blocks = 0;
    instruction = ATA_OP_WRITE_PIO_EXT;
    tf_init(&tf,instruction,lba_,blocks);

    return exec(fd_,SG_WRITE,SG_PIO,&tf,(void*)buf_,buflen_,timeout_);
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %r8, %rax
movq %rcx, %r8
movq %rsi, %rbx
xorl %esi, %esi
cmpl $0x10000, %edx          # imm = 0x10000
cmovgel %esi, %edx
leaq 0x10(%rsp), %rcx
movq %rsi, (%rcx)
movq %rsi, 0x7(%rcx)
movw $0x34e0, (%rcx)         # imm = 0x34E0
movb %bl, 0x7(%rcx)
movb %bh, 0x18(%rsp)
movl %ebx, %esi
shrl $0x10, %esi
movb %sil, 0x9(%rcx)
movb %dl, 0x6(%rcx)
movb $0x1, 0x4(%rcx)
movb $0x0, 0xa(%rcx)
movb %dh, 0x1b(%rsp)
movl %ebx, %edx
shrl $0x18, %edx
movb %dl, 0xc(%rcx)
movq %rbx, %rdx
shrq $0x20, %rdx
movb %dl, 0xd(%rcx)
shrq $0x28, %rbx
movb %bl, 0xe(%rcx)
movl %r9d, (%rsp)
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %r9d
callq 0x14814
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::flush_write_cache(int, int)
int
  flush_write_cache(const int fd,
                    const int timeout)
  {
    int rv;
    struct ata_tf tf;

    tf_init(&tf,ATA_OP_FLUSHCACHE_EXT,0,0);

    rv = exec(fd,SG_READ,SG_PIO,&tf,NULL,0,timeout);
    if(rv < 0)
      {
        tf_init(&tf,ATA_OP_FLUSHCACHE,0,0);

        rv = exec(fd,SG_READ,SG_PIO,&tf,NULL,0,timeout);
      }

    return rv;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movl %edi, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %rcx
movq %r14, (%rcx)
movq %r14, 0x7(%rcx)
movw $0xeae0, (%rcx)         # imm = 0xEAE0
movl %r14d, 0x6(%rcx)
movb $0x1, 0x4(%rcx)
movl %r14d, 0xa(%rcx)
movb $0x0, 0xe(%rcx)
movl %esi, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14814
testl %eax, %eax
jns 0x14fbc
leaq 0x1a(%rsp), %rax
movq %r14, -0xa(%rax)
movq %r14, -0x3(%rax)
movw $0xe7e0, -0xa(%rax)     # imm = 0xE7E0
movl %r14d, -0x4(%rax)
movb $0x1, -0x6(%rax)
movl %r14d, (%rax)
movb $0x0, 0x4(%rax)
movl %ebp, (%rsp)
leaq 0x10(%rsp), %rcx
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14814
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::write_uncorrectable(int, unsigned long, unsigned char, int)
int
  write_uncorrectable(const int      fd_,
                      const uint64_t lba_,
                      const uint8_t  type_,
                      const int      timeout_)
  {
    int rv;
    struct ata_tf tf;

    tf_init(&tf,ATA_OP_WRITE_UNC_EXT,lba_,1);
    tf.lob.feat = type_;
    tf.is_lba48 = 1;

    rv = exec(fd_,SG_READ,SG_PIO,&tf,NULL,0,timeout_);
    if(rv < 0)
      {
        char buf[520];

        tf_init(&tf,ATA_OP_WRITE_LONG_ONCE,lba_,1);
        memset(buf,0xA5,sizeof(buf));
        rv = exec(fd_,SG_WRITE,SG_PIO,&tf,buf,sizeof(buf),timeout_);
      }

    return rv;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movl %ecx, %r8d
movq %rsi, %r14
xorl %eax, %eax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x7(%rcx)
movw $0x45e0, (%rcx)         # imm = 0x45E0
movb %r14b, 0x7(%rcx)
movl %r14d, %r12d
shrl $0x8, %r12d
movb %r12b, 0x8(%rcx)
movl %r14d, %r13d
shrl $0x10, %r13d
movb %r13b, 0x9(%rcx)
movb $0x1, %al
movb %al, 0x6(%rcx)
movb %al, 0x4(%rcx)
movw $0x0, 0xa(%rcx)
movl %r14d, %r15d
shrl $0x18, %r15d
movb %r15b, 0xc(%rcx)
movq %rsi, %rbx
shrq $0x20, %rbx
movb %bl, 0xd(%rcx)
movq %rsi, %rbp
shrq $0x28, %rbp
movb %bpl, 0xe(%rcx)
movb %dl, 0x5(%rcx)
movl %r8d, 0x1c(%rsp)
movl %r8d, (%rsp)
movl %edi, 0x18(%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x14814
testl %eax, %eax
jns 0x150f5
movl 0x18(%rsp), %edx
movl 0x1c(%rsp), %ecx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0xf(%rsp)
movw $0x33e0, 0x8(%rsp)      # imm = 0x33E0
movb %r14b, 0xf(%rsp)
movb %r12b, 0x10(%rsp)
movb %r13b, 0x11(%rsp)
movb $0x1, 0xe(%rsp)
cmpq $0xfffffff, %r14        # imm = 0xFFFFFFF
jb 0x150b2
movb $0x1, 0xc(%rsp)
movw $0x0, 0x12(%rsp)
movb %r15b, 0x14(%rsp)
movb %bl, 0x15(%rsp)
movb %bpl, 0x16(%rsp)
jmp 0x150bb
orb $-0x20, %r15b
movb %r15b, 0x8(%rsp)
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x20(%rsp), %r14
movl $0x208, %edx            # imm = 0x208
movq %r14, %rdi
movl $0xa5, %esi
callq 0x4280
movl %ebx, (%rsp)
leaq 0x8(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
xorl %edx, %edx
movq %r14, %r8
movl $0x208, %r9d            # imm = 0x208
callq 0x14814
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::security_set_password(int, int, char const*, int)
int
  security_set_password(const int  fd_,
                        const int  identifier_,
                        const char password_[32],
                        const int  timeout_)
  {
    uint8_t data[512];
    struct ata_tf tf;

    ::memset(data,0,512);
    ::memcpy(&data[2],password_,32);
    switch(identifier_)
      {
      case SG_IDENTIFIER_USER:
        data[0] = 0x00;
        break;
      case SG_IDENTIFIER_MASTER:
        data[0] = 0x01;
      default:
        return -EINVAL;
      }

    tf_init(&tf,ATA_OP_SECURITY_SET_PASSWORD,0,0);

    return exec(fd_,SG_WRITE,SG_PIO,&tf,data,512,timeout_);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movl %ecx, %ebx
movq %rdx, %r15
movl %esi, %r14d
movl %edi, %ebp
leaq 0x20(%rsp), %r12
movl $0x200, %edx            # imm = 0x200
movq %r12, %rdi
xorl %esi, %esi
callq 0x4280
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, 0x2(%r12)
movups %xmm1, 0x12(%r12)
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
cmpl $0x1, %r14d
je 0x151bf
testl %r14d, %r14d
jne 0x151c4
xorl %eax, %eax
leaq 0x20(%rsp), %r8
movb %al, (%r8)
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x7(%rcx)
movw $0xf1e0, (%rcx)         # imm = 0xF1E0
movl %eax, 0x6(%rcx)
movb $0x1, 0x4(%rcx)
movb %al, 0xe(%rcx)
movl %eax, 0xa(%rcx)
movl %ebx, (%rsp)
movl %ebp, %edi
movl $0x1, %esi
xorl %edx, %edx
movl $0x200, %r9d            # imm = 0x200
callq 0x14814
jmp 0x151c4
movb $0x1, 0x20(%rsp)
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/sg.cpp
// Function: sg::security_erase(int, int, int, char const*, int)
int
  security_erase(const int  fd_,
                 const int  erase_mode_,
                 const int  identifier_,
                 const char password_[32],
                 const int  timeout_)
  {
    struct ata_tf tf;
    uint8_t data[512];

    ::memset(data,0,512);
    ::memcpy(&data[2],password_,32);
    switch(identifier_)
      {
      case SG_IDENTIFIER_USER:
        data[0] |= 0x00;
        break;
      case SG_IDENTIFIER_MASTER:
        data[0] |= 0x01;
        break;
      default:
        return -EINVAL;
      }

    switch(erase_mode_)
      {
      case SG_ERASE_NORMAL:
        data[0] |= 0x00;
        break;
      case SG_ERASE_ENHANCED:
        data[0] |= 0x02;
        break;
      default:
        return -EINVAL;
      }

    tf_init(&tf,ATA_OP_SECURITY_ERASE_UNIT,0,1);

    return exec(fd_,SG_WRITE,SG_PIO,&tf,data,512,timeout_);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movl %r8d, %ebx
movq %rcx, %r12
movl %edx, %r15d
movl %esi, %r14d
movl %edi, %ebp
leaq 0x20(%rsp), %r13
movl $0x200, %edx            # imm = 0x200
movq %r13, %rdi
xorl %esi, %esi
callq 0x4280
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, 0x2(%r13)
movups %xmm1, 0x12(%r13)
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
testl %r15d, %r15d
je 0x15266
cmpl $0x1, %r15d
jne 0x152b3
orb $0x1, 0x20(%rsp)
testl %r14d, %r14d
je 0x15276
cmpl $0x1, %r14d
jne 0x152b3
orb $0x2, 0x20(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rax, 0x7(%rcx)
movw $0xf4e0, (%rcx)         # imm = 0xF4E0
movb $0x0, 0x7(%rcx)
movw $0x0, 0x8(%rcx)
movb $0x1, 0x6(%rcx)
movl %ebx, (%rsp)
leaq 0x20(%rsp), %r8
movl %ebp, %edi
movl $0x1, %esi
xorl %edx, %edx
movl $0x200, %r9d            # imm = 0x200
callq 0x14814
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/trapexit[P]bbf/src/signals.cpp
// Function: signals::setup_handlers()
void
  setup_handlers()
  {
    struct sigaction sa = {0};

    sa.sa_flags   = SA_RESTART;
    sa.sa_handler = signals::handler;

    sigaction(SIGHUP,&sa,NULL);
    sigaction(SIGALRM,&sa,NULL);
    sigaction(SIGTERM,&sa,NULL);
    sigaction(SIGINT,&sa,NULL);
    sigaction(SIGQUIT,&sa,NULL);
    sigaction(SIGUSR1,&sa,NULL);
    sigaction(SIGUSR2,&sa,NULL);
  }

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x8(%rsp), %rbx
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4280
movl $0x10000000, 0x88(%rbx) # imm = 0x10000000
leaq -0x3b(%rip), %rax       # 0x1532e
movq %rax, (%rbx)
movl $0x1, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0xe, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0xf, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0x2, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0x3, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0xa, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
movl $0xc, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4560
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::Person(Person const&)
Person::Person(const Person& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_name(),
      GetArena());
  }
  email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_email()) {
    email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_email(),
      GetArena());
  }
  id_ = from.id_;
  // @@protoc_insertion_point(copy_constructor:Person)
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq $0x0, 0x8(%rdi)
leaq 0x5557(%rip), %rax      # 0x9c58
movq %rax, (%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x472b
andq $-0x2, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x579e
movq 0x5876(%rip), %r12      # 0x9fa8
movq %r12, 0x18(%rbx)
testb $0x1, 0x10(%r14)
je 0x4753
leaq 0x18(%rbx), %rdi
movq 0x18(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0x4787
callq 0x5456
movq %r12, 0x20(%rbx)
testb $0x2, 0x10(%r14)
je 0x4774
leaq 0x20(%rbx), %rdi
movq 0x20(%r14), %rdx
movq (%r15), %rsi
testb $0x1, %sil
jne 0x4790
callq 0x5456
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x474e
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x476f
nop
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::Clear()
void Person::Clear() {
// @@protoc_insertion_point(message_clear_start:Person)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      email_.ClearNonDefaultToEmpty();
    }
  }
  id_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

// Assembly:
movl 0x10(%rdi), %eax
testb $0x3, %al
je 0x4831
testb $0x1, %al
je 0x481b
movq 0x18(%rdi), %rcx
movq $0x0, 0x8(%rcx)
movq (%rcx), %rcx
movb $0x0, (%rcx)
testb $0x2, %al
je 0x4831
movq 0x20(%rdi), %rax
movq $0x0, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
xorl %eax, %eax
movl %eax, 0x28(%rdi)
movl %eax, 0x10(%rdi)
testb $0x1, 0x8(%rdi)
jne 0x4840
retq
addq $0x8, %rdi
jmp 0x57cc
nop
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::ByteSizeLong() const
size_t Person::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Person)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000005) ^ 0x00000005) == 0) {  // All required fields are present.
    // required string name = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());

    // required int32 id = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_id());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string email = 3;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000002u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_email());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %ebp
movl %ebp, %eax
notl %eax
testb $0x5, %al
jne 0x4d00
movq 0x18(%rbx), %rax
movq 0x8(%rax), %rax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
movl 0x28(%rbx), %edx
testl %edx, %edx
js 0x4d0a
orl $0x1, %edx
bsrl %edx, %edx
leal (%rdx,%rdx,8), %edx
addl $0x49, %edx
shrl $0x6, %edx
jmp 0x4d0f
movq %rbx, %rdi
callq 0x4c6a
jmp 0x4d19
movl $0xa, %edx
addq %rcx, %rax
addq %rdx, %rax
addq $0x2, %rax
testb $0x2, %bpl
je 0x4d3f
movq 0x20(%rbx), %rcx
movq 0x8(%rcx), %rcx
addq %rcx, %rax
orl $0x1, %ecx
bsrl %ecx, %ecx
leal (%rcx,%rcx,8), %ecx
addl $0x49, %ecx
shrl $0x6, %ecx
addq %rcx, %rax
incq %rax
testb $0x1, 0x8(%rbx)
jne 0x4d4f
movl %eax, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
addq $0x14, %rbx
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4060
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::MergeFrom(google::protobuf::Message const&)
void Person::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Person)
  GOOGLE_DCHECK_NE(&from, this);
  const Person* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Person>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Person)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Person)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rdi, %rsi
jne 0x4dc0
leaq 0x2348(%rip), %rdx      # 0x70cb
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x157, %ecx            # imm = 0x157
callq 0x4400
leaq 0x233c(%rip), %rsi      # 0x70dd
movq %r15, %rdi
callq 0x4420
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x4340
leaq 0x8(%rsp), %rdi
callq 0x4470
cmpq %r14, %rbx
leaq 0x4e8e(%rip), %rax      # 0x9c58
cmpq %rax, (%rbx)
je 0x4ddc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4280
jmp 0x4de7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e08
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x4df3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4480
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::MergeFrom(Person const&)
void Person::MergeFrom(const Person& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Person)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_email(from._internal_email());
    }
    if (cached_has_bits & 0x00000004u) {
      id_ = from.id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq %rdi, %rsi
jne 0x4e61
leaq 0x22a7(%rip), %rdx      # 0x70cb
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x3, %esi
movl $0x166, %ecx            # imm = 0x166
callq 0x4400
leaq 0x229b(%rip), %rsi      # 0x70dd
movq %r15, %rdi
callq 0x4420
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x4340
leaq 0x10(%rsp), %rdi
callq 0x4470
cmpq %rbx, %r14
movq 0x8(%r14), %rsi
testb $0x1, %sil
je 0x4e7f
leaq 0x8(%rbx), %rdi
andq $-0x2, %rsi
addq $0x8, %rsi
callq 0x579e
movl 0x10(%r14), %ebp
testb $0x7, %bpl
je 0x4f11
testb $0x1, %bpl
je 0x4ec7
movq 0x18(%r14), %rdx
orl $0x1, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
movq 0x8(%rbx), %rsi
testb $0x1, %sil
jne 0x4f1c
movq (%rdi), %rax
cmpq 0x50f5(%rip), %rax      # 0x9fa8
je 0x4ec2
movq %rax, %rdi
movq %rdx, %rsi
callq 0x4180
jmp 0x4ec7
callq 0x5456
testb $0x2, %bpl
je 0x4f01
movq 0x20(%r14), %rdx
orl $0x2, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
movq 0x8(%rbx), %rsi
testb $0x1, %sil
jne 0x4f25
movq (%rdi), %rax
cmpq 0x50bb(%rip), %rax      # 0x9fa8
je 0x4efc
movq %rax, %rdi
movq %rdx, %rsi
callq 0x4180
jmp 0x4f01
callq 0x5456
testb $0x4, %bpl
je 0x4f0e
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
orl %ebp, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x4ea9
andq $-0x2, %rsi
movq (%rsi), %rsi
jmp 0x4ee3
jmp 0x4f30
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4480
nop
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/cpp/example.pb.cc
// Function: Person::InternalSwap(Person*)
void Person::InternalSwap(Person* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  email_.Swap(&other->email_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(id_, other->id_);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rdi
testb $0x1, 0x8(%r14)
jne 0x4fc1
testb $0x1, (%rdi)
je 0x4fe2
leaq 0x8(%r14), %r15
movq (%rdi), %rsi
testb $0x1, %sil
je 0x512a
andq $-0x2, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x5800
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
leaq 0x18(%r14), %r12
movq 0x8(%r14), %r15
testb $0x1, %r15b
jne 0x5112
leaq 0x18(%rbx), %r13
movq (%r12), %rax
cmpq 0x4f97(%rip), %rax      # 0x9fa8
je 0x50b0
movq (%r12), %r12
movq (%r13), %rax
cmpq 0x4f82(%rip), %rax      # 0x9fa8
jne 0x503a
movq 0x4f79(%rip), %rdx      # 0x9fa8
movq %r13, %rdi
movq %r15, %rsi
callq 0x5456
movq (%r13), %rsi
movq %r12, %rdi
callq 0x4200
leaq 0x20(%r14), %r12
movq 0x8(%r14), %r15
testb $0x1, %r15b
jne 0x511e
leaq 0x20(%rbx), %r13
movq (%r12), %rax
cmpq 0x4f41(%rip), %rax      # 0x9fa8
je 0x50e1
movq (%r12), %r12
movq (%r13), %rax
cmpq 0x4f30(%rip), %rax      # 0x9fa8
jne 0x508c
movq 0x4f27(%rip), %rdx      # 0x9fa8
movq %r13, %rdi
movq %r15, %rsi
callq 0x5456
movq (%r13), %rsi
movq %r12, %rdi
callq 0x4200
movl 0x28(%r14), %eax
movl 0x28(%rbx), %ecx
movl %ecx, 0x28(%r14)
movl %eax, 0x28(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r13), %rcx
cmpq 0x4eed(%rip), %rcx      # 0x9fa8
je 0x5046
cmpq 0x4ee4(%rip), %rax      # 0x9fa8
jne 0x5017
movq 0x4ed7(%rip), %rdx      # 0x9fa8
movq %r12, %rdi
movq %r15, %rsi
callq 0x5456
jmp 0x5017
movq (%r13), %rcx
cmpq 0x4ebc(%rip), %rcx      # 0x9fa8
je 0x5098
cmpq 0x4eb3(%rip), %rax      # 0x9fa8
jne 0x5069
movq 0x4ea6(%rip), %rdx      # 0x9fa8
movq %r12, %rdi
movq %r15, %rsi
callq 0x5456
jmp 0x5069
andq $-0x2, %r15
movq (%r15), %r15
jmp 0x5002
andq $-0x2, %r15
movq (%r15), %r15
jmp 0x5058
callq 0x56ce
movq %rax, %rsi
jmp 0x4fda
nop
// File: /workspace/github_cpp_makefile_star2_O1/vgteam[P]stream/src/stream.hpp
// Function: bool stream::write_buffered<Person>(std::ostream&, std::vector<Person, std::allocator<Person>>&, unsigned long)
bool write_buffered(std::ostream& out, std::vector<T>& buffer, uint64_t buffer_limit) {
    bool wrote = false;
    if (buffer.size() >= buffer_limit) {
        std::function<T(uint64_t)> lambda = [&buffer](uint64_t n) { return buffer.at(n); };
#pragma omp critical (stream_out)
        wrote = write(out, buffer.size(), lambda);
        buffer.clear();
    }
    return wrote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
cmpq %rdx, %rsi
jae 0x5e8b
xorl %ebp, %ebp
jmp 0x5ef3
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rbx, (%rdx)
leaq 0x5f8(%rip), %rax       # 0x649a
movq %rax, 0x18(%rdx)
leaq 0x5fb(%rip), %rax       # 0x64a8
movq %rax, 0x10(%rdx)
callq 0x61ab
movl %eax, %ebp
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r15, %r12
je 0x5edc
movq %r15, %r14
movq %r14, %rdi
callq 0x479a
addq $0x30, %r14
cmpq %r12, %r14
jne 0x5ec7
movq %r15, 0x8(%rbx)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5ef3
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f26
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x5f1e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x4480
movq %rax, %rdi
callq 0x52e3
// File: /workspace/github_cpp_makefile_star2_O1/davmac314[P]dinit/src/dinit-monitor.cc
// Function: request_environ(int, cpbuffer<1024u>&, unsigned short)
static void request_environ(int socknum, cpbuffer_t &rbuffer, uint16_t proto_version)
{
    char c = (char)cp_cmd::LISTENENV;

    if (proto_version < 5) {
        throw cp_old_server_exception();
    }

    write_all_x(socknum, &c, 1);

    wait_for_reply(rbuffer, socknum);

    cp_rply reply_pkt_h = (cp_rply)rbuffer[0];
    if (reply_pkt_h != cp_rply::ACK) {
        throw dinit_protocol_error();
    }
    rbuffer.consume(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1b, 0x7(%rsp)
cmpw $0x5, %dx
jb 0x3c12
movq %rsi, %rbx
movl %edi, %ebp
movl $0x1, %r12d
leaq 0x7(%rsp), %r14
xorl %r15d, %r15d
movl %r12d, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x20a0
cmpl $-0x1, %eax
je 0x3b8c
addl %eax, %r15d
movslq %eax, %rcx
addq %rcx, %r14
subl %eax, %r12d
xorl %ecx, %ecx
jmp 0x3bad
callq 0x2040
movl $0x2, %ecx
cmpl $0x4, (%rax)
je 0x3bad
testl %r15d, %r15d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmovgl %r15d, %r13d
movl $0x1, %ecx
testb $0x1, %cl
jne 0x3bb9
testl %r12d, %r12d
jg 0x3b6a
jmp 0x3bbc
movl %r13d, %r15d
cmpl $-0x1, %r15d
je 0x3c25
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4c62
movl 0x400(%rbx), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x32, (%rbx,%rcx)
jne 0x3c47
leal 0x1(%rax), %ecx
addl $0xfffffc01, %eax       # imm = 0xFFFFFC01
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %eax
movl %eax, 0x400(%rbx)
decl 0x404(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x2100
leaq 0x612d(%rip), %rsi      # 0x9d50
jmp 0x3c58
movl $0x4, %edi
callq 0x2100
movq %rax, %rbx
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x6136(%rip), %rsi      # 0x9d78
movq %rbx, %rdi
jmp 0x3c5b
movl $0x1, %edi
callq 0x2100
leaq 0x60d0(%rip), %rsi      # 0x9d28
movq %rax, %rdi
xorl %edx, %edx
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/davmac314[P]dinit/src/dinit-monitor.cc
// Function: get_allenv(int, cpbuffer<1024u>&)
static size_t get_allenv(int socknum, cpbuffer_t &rbuffer)
{
    char buf[2] = { (char)cp_cmd::GETALLENV, 0 };
    write_all_x(socknum, buf, 2);

    wait_for_reply(rbuffer, socknum);

    cp_rply reply_pkt_h = (cp_rply)rbuffer[0];
    if (reply_pkt_h != cp_rply::ALLENV) {
        throw dinit_protocol_error();
    }

    // 1-byte packet header, then size_t
    constexpr size_t allenv_hdr_size = 1 + sizeof(size_t);
    rbuffer.fill_to(socknum, allenv_hdr_size);

    size_t dsize;
    rbuffer.extract(&dsize, 1, sizeof(dsize));
    rbuffer.consume(allenv_hdr_size);

    return dsize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xe(%rsp), %r14
movw $0x18, (%r14)
movl $0x2, %r12d
xorl %r15d, %r15d
movl %r12d, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x20a0
cmpl $-0x1, %eax
je 0x3cab
addl %eax, %r15d
movslq %eax, %rcx
addq %rcx, %r14
subl %eax, %r12d
xorl %ecx, %ecx
jmp 0x3ccc
callq 0x2040
movl $0x2, %ecx
cmpl $0x4, (%rax)
je 0x3ccc
testl %r15d, %r15d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmovgl %r15d, %r13d
movl $0x1, %ecx
testb $0x1, %cl
jne 0x3cd8
testl %r12d, %r12d
jg 0x3c89
jmp 0x3cdb
movl %r13d, %r15d
cmpl $-0x1, %r15d
je 0x3dd3
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4c62
movl 0x400(%rbx), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x4e, (%rbx,%rcx)
jne 0x3df5
cmpl $0x8, 0x404(%rbx)
ja 0x3d2d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x55a8
testl %eax, %eax
jle 0x3d2d
cmpl $0x9, 0x404(%rbx)
jb 0x3d16
movl 0x400(%rbx), %r14d
leal 0x1(%r14), %eax
addl $0xfffffc01, %r14d      # imm = 0xFFFFFC01
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %r14d
leal -0x3f9(%r14), %eax
cmpl $0xfffffbfe, %eax       # imm = 0xFFFFFBFE
ja 0x3d8f
movl $0x400, %r15d           # imm = 0x400
subl %r14d, %r15d
movl %r14d, %esi
addq %rbx, %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x2180
addq %r12, %r15
addl $0xfffffc08, %r14d      # imm = 0xFFFFFC08
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2180
jmp 0x3d9b
movl %r14d, %eax
movq (%rbx,%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x400(%rbx), %eax
leal 0x9(%rax), %ecx
addl $0xfffffc09, %eax       # imm = 0xFFFFFC09
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %eax
movl %eax, 0x400(%rbx)
addl $-0x9, 0x404(%rbx)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x2100
movq %rax, %rbx
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x5f88(%rip), %rsi      # 0x9d78
movq %rbx, %rdi
jmp 0x3e09
movl $0x1, %edi
callq 0x2100
leaq 0x5f22(%rip), %rsi      # 0x9d28
movq %rax, %rdi
xorl %edx, %edx
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/davmac314[P]dinit/src/includes/dinit-client.h
// Function: get_default_socket_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
inline const char *get_default_socket_path(std::string &control_socket_str, bool user_dinit)
{
    const char *control_socket_path;
    const char *sockpath = getenv("DINIT_SOCKET_PATH");
    if (sockpath) {
        control_socket_str = sockpath;
        control_socket_path = control_socket_str.c_str();
    }
    else if (user_dinit) {
        const char * rundir = getenv("XDG_RUNTIME_DIR");
        const char * sockname = "dinitctl";
        if (rundir == nullptr) {
            sockname = ".dinitctl";
            rundir = getenv("HOME");
            if (rundir == nullptr) {
                struct passwd * pwuid_p = getpwuid(getuid());
                if (pwuid_p != nullptr) {
                    rundir = pwuid_p->pw_dir;
                }
            }
        }

        if (rundir != nullptr) {
            control_socket_str = rundir;
            control_socket_str.push_back('/');
            control_socket_str += sockname;
            control_socket_path = control_socket_str.c_str();
        }
        else {
            return nullptr;
        }
    }
    else {
        control_socket_path = SYSCONTROLSOCKET; // default to system
    }
    return control_socket_path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2375(%rip), %rdi      # 0x68df
callq 0x2270
testq %rax, %rax
je 0x459e
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %rax, %rdi
callq 0x20e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2340
movq (%rbx), %rax
jmp 0x4643
testb %bpl, %bpl
je 0x45c0
leaq 0x2347(%rip), %rdi      # 0x68f1
callq 0x2270
testq %rax, %rax
je 0x45c9
movq %rax, %r15
leaq 0x2344(%rip), %r14      # 0x6902
jmp 0x4600
leaq 0x2470(%rip), %rax      # 0x6a37
jmp 0x4643
leaq 0x233b(%rip), %rdi      # 0x690b
callq 0x2270
leaq 0x2325(%rip), %r14      # 0x6901
testq %rax, %rax
je 0x45e6
movq %rax, %r15
jmp 0x4600
callq 0x2110
movl %eax, %edi
callq 0x2240
testq %rax, %rax
je 0x45fd
movq 0x20(%rax), %r15
jmp 0x4600
xorl %r15d, %r15d
testq %r15, %r15
je 0x4641
movq 0x8(%rbx), %r12
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x2340
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23e0
jmp 0x4596
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/main.cpp
// Function: print(TreeNode*)
void print(TreeNode *p)
{
	cout<<"Current Address: "<<p<<endl;
	cout<<"Word: ("<<p->Node_Word.Number<<","<<p->Node_Word.Value<<")"<<endl;
	cout<<"Son_Count: "<<p->Next.size()<<endl;
	for(int i=0;i<p->Next.size();i++)
	{
		cout<<"\tAddress: "<<p->Next[i]<<endl;
	}
	cout<<"Parent: "<<p->Parent<<endl;
	cout<<endl;
	for(int i=0;i<p->Next.size();i++)
	{
		print(p->Next[i]);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7b2f(%rip), %r14      # 0x9fd0
leaq 0x4b5c(%rip), %rsi      # 0x7004
movl $0x11, %edx
movq %r14, %rdi
callq 0x21c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x4b25(%rip), %rsi      # 0x7016
movl $0x7, %edx
movq %r14, %rdi
callq 0x21c0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x2260
movq %rax, %r15
leaq 0x4b0c(%rip), %rsi      # 0x701e
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movsd 0x8(%rbx), %xmm0
movq %r15, %rdi
callq 0x2230
movq %rax, %r15
leaq 0x4c56(%rip), %rsi      # 0x718c
movl $0x1, %edx
movq %rax, %rdi
callq 0x21c0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x4aaf(%rip), %rsi      # 0x7020
movl $0xb, %edx
movq %r14, %rdi
callq 0x21c0
movq 0x18(%rbx), %rsi
subq 0x10(%rbx), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x2634
xorl %ebp, %ebp
movq 0x7a01(%rip), %r15      # 0x9fd0
leaq 0x4a56(%rip), %r12      # 0x702c
movl $0xa, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
callq 0x2120
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incq %rbp
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
ja 0x25d6
leaq 0x49fc(%rip), %rsi      # 0x7037
movl $0x8, %edx
movq %r14, %rdi
callq 0x21c0
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x2120
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x10(%rbx), %rax
cmpq %rax, 0x18(%rbx)
je 0x26d2
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
callq 0x248c
incq %r14
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x26b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Var_Number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Lexical::Get_Var_Number(std::string s)
{
	if(this->Symbol_Table[s]==0)
	{
		int num=this->Symbol_Table.size();
		this->Symbol_Table[s]=num;
	}
	return this->Symbol_Table[s];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x3b4a
cmpl $0x0, (%rax)
jne 0x35a3
movl 0x60(%r15), %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b4a
movl %ebp, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b4a
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Keyword(int&)
Word Lexical::Get_Keyword(int &pos)
{
	if(pos+2<this->Source.length())
	{
		std::string check;
		check+=this->Source[pos];
		check+=this->Source[pos+1];
		check+=this->Source[pos+2];
		if(check=="var")
		{
			pos+=3;
			return Word(1,0);
		}
	}
	
	if(pos+4<this->Source.length())
	{
		std::string check;
		check+=this->Source[pos];
		check+=this->Source[pos+1];
		check+=this->Source[pos+2];
		check+=this->Source[pos+3];
		check+=this->Source[pos+4];
		if(check=="print")
		{
			pos+=5;
			return Word(2,0);
		}
	}
	
	return Word(-1,0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %rax
leaq 0x2(%rax), %rcx
cmpq %rcx, 0x8(%rdi)
jbe 0x3666
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rcx
movsbl (%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x1(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x2(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
leaq 0x3aec(%rip), %rsi      # 0x7120
leaq 0x8(%rsp), %rdi
callq 0x2080
movl %eax, %ebp
testl %eax, %eax
jne 0x3647
addl $0x3, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x365e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %ebp, %ebp
je 0x3739
movslq (%rbx), %rax
leaq 0x4(%rax), %rcx
cmpq %rcx, 0x8(%r14)
jbe 0x3732
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rcx
movsbl (%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x1(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x2(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x3(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
movslq (%rbx), %rax
movq (%r14), %rcx
movsbl 0x4(%rcx,%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x2150
leaq 0x3a2c(%rip), %rsi      # 0x7124
leaq 0x8(%rsp), %rdi
callq 0x2080
movl %eax, %r14d
movl $0x1, %ebp
testl %eax, %eax
jne 0x3716
addl $0x5, (%rbx)
movl $0x2, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x372d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testl %r14d, %r14d
je 0x373e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x373e
movl $0x1, %ebp
xorps %xmm0, %xmm0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3750
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x376a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Var(int&)
Word Lexical::Get_Var(int &pos)
{
	if(!isalpha(this->Source[pos]))return Word(-1,0);
	
	std::string s;

	while((pos<this->Source.length())&&(isalpha(this->Source[pos]))||(isdigit(this->Source[pos])))
	{
		s+=this->Source[pos];
		pos++;
	}
	
	return Word(3,this->Get_Var_Number(s));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %rax
movq (%rdi), %rcx
movsbl (%rcx,%rax), %edi
callq 0x2220
testl %eax, %eax
je 0x385c
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %r15
movslq (%r14), %r13
cmpq %r13, 0x8(%rbx)
jbe 0x37d1
movq (%rbx), %rax
movsbl (%rax,%r13), %edi
callq 0x2220
testl %eax, %eax
jne 0x37e1
movq (%rbx), %rax
movsbl (%rax,%r13), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x37f6
movq (%rbx), %rax
movsbl (%rax,%r13), %esi
movq %r15, %rdi
callq 0x2150
incl (%r14)
jmp 0x37b7
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x34e2
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3574
movl %eax, %ebx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x383b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21a0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3851
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
cvtsi2sd %ebx, %xmm0
movl $0x3, %eax
jmp 0x3864
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x3893
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3893
jmp 0x3890
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x38a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Number(int&)
Word Lexical::Get_Number(int &pos)
{	
	if(!isdigit(this->Source[pos]))return Word(-1,0);
	
	double ret=0;
	
	while((pos<this->Source.length())&&(isdigit(this->Source[pos])))
	{
		ret=ret*10+(this->Source[pos]-'0');
		pos++;
	}
	
	if(this->Source[pos]=='.')
	{
		double k=0.1;
		pos++;
		while((pos<this->Source.length())&&(isdigit(this->Source[pos])))
		{
			ret=ret+(this->Source[pos]-'0')*k;
			pos++;
			k/=10;
		}
	}
	
	return Word(4,ret);
}

// Assembly:
movslq (%rsi), %rax
movq (%rdi), %rcx
movsbl (%rcx,%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x396d
movq 0x8(%rdi), %rdx
movl (%rsi), %edi
movslq %edi, %r8
xorpd %xmm0, %xmm0
cmpq %r8, %rdx
jbe 0x390f
incl %edi
movsd 0x380c(%rip), %xmm1     # 0x70f0
movsbl (%rcx,%r8), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x390c
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
incq %r8
movl %edi, (%rsi)
incl %edi
cmpq %r8, %rdx
ja 0x38e4
movl %r8d, %edi
movl $0x4, %eax
cmpb $0x2e, (%rcx,%r8)
jne 0x396c
leal 0x1(%rdi), %r8d
movl %r8d, (%rsi)
movslq %r8d, %r8
cmpq %r8, %rdx
jbe 0x396c
addl $0x2, %edi
movsd 0x37c3(%rip), %xmm1     # 0x70f8
movsd 0x37b3(%rip), %xmm2     # 0x70f0
movsbl (%rcx,%r8), %r9d
addl $-0x30, %r9d
cmpl $0x9, %r9d
ja 0x396c
xorps %xmm3, %xmm3
cvtsi2sd %r9d, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm0
incq %r8
movl %edi, (%rsi)
divsd %xmm2, %xmm1
incl %edi
cmpq %r8, %rdx
ja 0x393d
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Symbol(int&)
Word Lexical::Get_Symbol(int &pos)
{
	switch(this->Source[pos])
	{
		case '+':pos++;return Word(5,0);break;
		case '-':pos++;return Word(6,0);break;
		case '*':pos++;return Word(7,0);break;
		case '/':pos++;return Word(8,0);break;
		case '=':pos++;return Word(9,0);break;
		case '(':pos++;return Word(10,0);break;
		case ')':pos++;return Word(11,0);break;
		case ';':pos++;return Word(12,0);break;
		default:return Word(-1,0);
	}
}

// Assembly:
movslq (%rsi), %rcx
movq (%rdi), %rax
movzbl (%rax,%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leal -0x28(%rdx), %edi
cmpl $0x7, %edi
ja 0x39a4
leaq 0x376c(%rip), %rdx      # 0x7100
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
movl $0xa, %eax
jmp 0x39dd
cmpl $0x3b, %edx
je 0x39d8
cmpl $0x3d, %edx
jne 0x39e1
movl $0x9, %eax
jmp 0x39dd
movl $0x5, %eax
jmp 0x39dd
movl $0xb, %eax
jmp 0x39dd
movl $0x6, %eax
jmp 0x39dd
movl $0x7, %eax
jmp 0x39dd
movl $0x8, %eax
jmp 0x39dd
movl $0xc, %eax
incl %ecx
movl %ecx, (%rsi)
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Next_Word(int&)
Word Lexical::Get_Next_Word(int &pos)
{
	Word ret;
	
	ret=this->Get_Keyword(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Var(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Number(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Symbol(pos);
	if(ret.Number!=-1)return ret;
	
	return Word(-1,0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x35bc
cmpl $-0x1, %eax
jne 0x3a33
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3772
cmpl $-0x1, %eax
jne 0x3a33
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38b2
cmpl $-0x1, %eax
jne 0x3a33
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3976
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
cmpl $-0x1, %eax
je 0x3a33
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Analysis()
bool Lexical::Analysis()
{
	int pos=0;
	while(pos<this->Source.length())
	{
		if(!isgraph(this->Source[pos]))
		{
			pos++;
			continue;
		}
		Word w=this->Get_Next_Word(pos);
		if(w.Number==-1)
		{
			this->Target.List.clear();
			return false;
		} 
		this->Target.List.push_back(w);
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rdi)
sete %bpl
je 0x3b22
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
xorl %eax, %eax
leaq 0x4(%rsp), %r15
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
movq (%rbx), %rcx
movsbl (%rcx,%rax), %edi
callq 0x2170
testl %eax, %eax
je 0x3ae1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39e6
movl %eax, %r13d
movl %eax, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
cmpl $-0x1, %eax
je 0x3aeb
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x3afb
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x28(%rbx)
jmp 0x3b06
incl %r13d
movl %r13d, 0x4(%rsp)
jmp 0x3b0c
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x3b06
movq %rax, 0x28(%rbx)
jmp 0x3b06
movq %r14, %rdi
movq %r12, %rdx
callq 0x3f4a
cmpl $-0x1, %r13d
je 0x3b22
movl 0x4(%rsp), %r13d
movslq %r13d, %rax
cmpq %rax, 0x8(%rbx)
setbe %bpl
ja 0x3a9b
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Caproner[P]Naive_Compiler/Grammar/Grammar.cpp
// Function: Grammar::Input(Word_List)
void Grammar::Input(Word_List WL)
{
	this->Handle_List.clear();
	Word_List PWL;
	
	for(int pos=0;pos<WL.List.size();pos++)
	{
		Word &W=WL.List[pos];
		if(W.Number==12)
		{
			this->Handle_List.push_back(PWL);
			PWL.List.clear();
		}
		else
		{
			PWL.List.push_back(W);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
callq 0x5f0e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rbx), %rdx
cmpq %rdx, 0x8(%rbx)
je 0x4ada
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
cmpl $0xc, (%rdx,%r12)
jne 0x4a9b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d40
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x4ac0
movq %rax, 0x8(%rsp)
jmp 0x4ac0
addq %r12, %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x4ab8
movups (%rdx), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x4ac0
movq %r15, %rdi
callq 0x3f4a
incq %r13
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x4, %rax
addq $0x10, %r12
cmpq %r13, %rax
ja 0x4a77
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4af0
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4b17
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2270
nop