LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x30(%rbp)
cmpl $0x10000, -0x30(%rbp)   # imm = 0x10000
jl 0x21866
movl $0x0, -0x30(%rbp)
movl $0x24, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rdx
movl -0x30(%rbp), %ecx
leaq -0x43(%rbp), %rdi
movzbl %al, %esi
callq 0x20a60
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movl %eax, %r9d
movl -0x2c(%rbp), %eax
xorl %edx, %edx
leaq -0x43(%rbp), %rcx
movl %edx, %esi
movl %eax, (%rsp)
callq 0x20c50
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x30(%rbp)
cmpl $0x10000, -0x30(%rbp)   # imm = 0x10000
jl 0x218e6
movl $0x0, -0x30(%rbp)
movl $0x34, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rdx
movl -0x30(%rbp), %ecx
leaq -0x43(%rbp), %rdi
movzbl %al, %esi
callq 0x20a60
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
movl %eax, %r9d
movl -0x2c(%rbp), %eax
movl $0x1, %esi
xorl %edx, %edx
leaq -0x43(%rbp), %rcx
movl %eax, (%rsp)
callq 0x20c50
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x1b(%rbp), %rdi
movl $0xea, %esi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x20a60
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %eax
xorl %r9d, %r9d
leaq -0x1b(%rbp), %rcx
xorl %edx, %edx
movl %edx, %r8d
movl %r9d, %esi
movl %r9d, %edx
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x219b2
leaq -0x1b(%rbp), %rdi
movl $0xe7, %esi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x20a60
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %eax
xorl %r9d, %r9d
leaq -0x1b(%rbp), %rcx
xorl %edx, %edx
movl %edx, %r8d
movl %r9d, %esi
movl %r9d, %edx
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x2b(%rbp), %rdi
movl $0x45, %esi
movl $0x1, %ecx
callq 0x20a60
movb -0x11(%rbp), %al
movb %al, -0x26(%rbp)
movb $0x1, -0x27(%rbp)
movl -0x4(%rbp), %edi
movl -0x18(%rbp), %eax
xorl %r9d, %r9d
leaq -0x2b(%rbp), %rcx
xorl %edx, %edx
movl %edx, %r8d
movl %r9d, %esi
movl %r9d, %edx
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x21a7a
movq -0x10(%rbp), %rdx
leaq -0x2b(%rbp), %rdi
movl $0x33, %esi
movl $0x1, %ecx
callq 0x20a60
leaq -0x240(%rbp), %rdi
movl $0xa5, %esi
movl $0x208, %edx            # imm = 0x208
callq 0x42b0
movl -0x4(%rbp), %edi
leaq -0x240(%rbp), %r8
movl -0x18(%rbp), %eax
movl $0x1, %esi
xorl %edx, %edx
leaq -0x2b(%rbp), %rcx
movl $0x208, %r9d            # imm = 0x208
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x42b0
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, -0x20e(%rbp)
movups %xmm0, -0x21e(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x234(%rbp)
testl %eax, %eax
je 0x21b90
jmp 0x21b83
movl -0x234(%rbp), %eax
subl $0x1, %eax
je 0x21b99
jmp 0x21ba0
movb $0x0, -0x220(%rbp)
jmp 0x21ba9
movb $0x1, -0x220(%rbp)
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x21bec
leaq -0x22f(%rbp), %rdi
movl $0xf1, %esi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x20a60
movl -0x8(%rbp), %edi
leaq -0x220(%rbp), %r8
movl -0x1c(%rbp), %eax
movl $0x1, %esi
xorl %edx, %edx
leaq -0x22f(%rbp), %rcx
movl $0x200, %r9d            # imm = 0x200
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x42b0
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, -0x21e(%rbp)
movups %xmm0, -0x22e(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x234(%rbp)
testl %eax, %eax
je 0x21cb4
jmp 0x21ca7
movl -0x234(%rbp), %eax
subl $0x1, %eax
je 0x21cc6
jmp 0x21cd8
movzbl -0x230(%rbp), %eax
orl $0x0, %eax
movb %al, -0x230(%rbp)
jmp 0x21ce4
movzbl -0x230(%rbp), %eax
orl $0x1, %eax
movb %al, -0x230(%rbp)
jmp 0x21ce4
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x21d6d
movl -0xc(%rbp), %eax
movl %eax, -0x238(%rbp)
testl %eax, %eax
je 0x21d00
jmp 0x21cf3
movl -0x238(%rbp), %eax
subl $0x1, %eax
je 0x21d12
jmp 0x21d24
movzbl -0x230(%rbp), %eax
orl $0x0, %eax
movb %al, -0x230(%rbp)
jmp 0x21d2d
movzbl -0x230(%rbp), %eax
orl $0x2, %eax
movb %al, -0x230(%rbp)
jmp 0x21d2d
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x21d6d
leaq -0x2b(%rbp), %rdi
movl $0xf4, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0x20a60
movl -0x8(%rbp), %edi
leaq -0x230(%rbp), %r8
movl -0x1c(%rbp), %eax
movl $0x1, %esi
xorl %edx, %edx
leaq -0x2b(%rbp), %rcx
movl $0x200, %r9d            # imm = 0x200
movl %eax, (%rsp)
callq 0x20c50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
nopl (%rax)
// File: trapexit[P]bbf/src/signals.cpp
// Function: signals::signaled_to_exit()
int
  signaled_to_exit(void)
  {
    if(signals::get(SIGTERM))
      return SIGTERM;
    if(signals::get(SIGINT))
      return SIGINT;
    if(signals::get(SIGQUIT))
      return SIGQUIT;

    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xf, %edi
callq 0x21fa0
cmpl $0x0, %eax
je 0x22060
movl $0xf, -0x4(%rbp)
jmp 0x22097
movl $0x2, %edi
callq 0x21fa0
cmpl $0x0, %eax
je 0x22078
movl $0x2, -0x4(%rbp)
jmp 0x22097
movl $0x3, %edi
callq 0x21fa0
cmpl $0x0, %eax
je 0x22090
movl $0x3, -0x4(%rbp)
jmp 0x22097
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x42b0
movl $0x10000000, -0x10(%rbp) # imm = 0x10000000
leaq -0x4c(%rip), %rax       # 0x220a0
movq %rax, -0x98(%rbp)
movl $0x1, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0xe, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0x3, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0xa, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
movl $0xc, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x4670
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: vgteam[P]stream/cpp/example.pb.cc
// Function: InitDefaultsscc_info_Person_example_2eproto()
static void InitDefaultsscc_info_Person_example_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_Person_default_instance_;
    new (ptr) ::Person();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Person::InitAsDefaultInstance();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2df5a4, %edi         # imm = 0x2DF5A4
movl $0x2df5a0, %esi         # imm = 0x2DF5A0
leaq 0x7912(%rip), %rdx      # 0xc0cb
callq 0x43d0
leaq 0xcc03(%rip), %rax      # 0x113c8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6c10
movq -0x8(%rbp), %rdi
callq 0x6c30
callq 0x47f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x4cc5
movl -0x3c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4cab
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x6350
movl -0x3c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4cc3
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0x6350
jmp 0x4cc5
movq -0x48(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x41a0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x4d21
movq -0x50(%rbp), %rdi
callq 0x8060
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: vgteam[P]stream/cpp/example.pb.cc
// Function: Person::RequiredFieldsByteSizeFallback() const
size_t Person::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Person)
  size_t total_size = 0;

  if (_internal_has_name()) {
    // required string name = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());
  }

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

  return total_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x5ed0
testb $0x1, %al
jne 0x5317
jmp 0x5334
movq -0x18(%rbp), %rdi
callq 0x5f70
movq %rax, %rdi
callq 0x68c0
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x68f0
testb $0x1, %al
jne 0x5343
jmp 0x535f
movq -0x18(%rbp), %rdi
callq 0x68a0
movl %eax, %edi
callq 0x6930
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x48(%rbp)
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x5, %eax
xorl $0x5, %eax
cmpl $0x0, %eax
jne 0x53ec
movq -0x58(%rbp), %rdi
callq 0x5f70
movq %rax, %rdi
callq 0x68c0
movq -0x58(%rbp), %rdi
addq $0x1, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x68a0
movl %eax, %edi
callq 0x6930
addq $0x1, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x53fd
movq -0x58(%rbp), %rdi
callq 0x52f0
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
movl $0x0, -0x4c(%rbp)
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x544d
movq -0x58(%rbp), %rdi
callq 0x6040
movq %rax, %rdi
callq 0x68c0
addq $0x1, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x548f
movq -0x58(%rbp), %rdx
movq %rdx, %rdi
addq $0x8, %rdi
movq -0x48(%rbp), %rsi
addq $0x14, %rdx
callq 0x4060
movq %rax, -0x38(%rbp)
jmp 0x54af
movq -0x48(%rbp), %rdi
callq 0x6950
movq -0x58(%rbp), %rdi
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %esi
callq 0x4c00
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x54ea
jmp 0x5533
leaq 0x6bda(%rip), %rdx      # 0xc0cb
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %esi
movl $0x157, %ecx            # imm = 0x157
callq 0x4500
movq -0x80(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq 0x6bc6(%rip), %rsi      # 0xc0dd
callq 0x4520
movq %rax, -0x78(%rbp)
jmp 0x5522
movq -0x78(%rbp), %rsi
leaq -0x5d(%rbp), %rdi
callq 0x4430
jmp 0x5531
jmp 0x5533
testb $0x1, -0x49(%rbp)
jne 0x553b
jmp 0x5544
leaq -0x48(%rbp), %rdi
callq 0x4570
movq -0x10(%rbp), %rdi
callq 0x6960
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x5586
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x42f0
jmp 0x5593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x557b
jmp 0x5584
leaq -0x48(%rbp), %rdi
callq 0x4570
jmp 0x559c
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x55b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: vgteam[P]stream/cpp/example.pb.cc
// Function: Person::CopyFrom(google::protobuf::Message const&)
void Person::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Person)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x5840
jmp 0x5856
movq -0x18(%rbp), %rdi
callq 0x4c50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x54c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vgteam[P]stream/cpp/example.pb.cc
// Function: Person::CopyFrom(Person const&)
void Person::CopyFrom(const Person& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Person)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x5880
jmp 0x5896
movq -0x18(%rbp), %rdi
callq 0x4c50
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: vgteam[P]stream/cpp/example.pb.cc
// Function: Person::SharedCtor()
void Person::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Person_example_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  email_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  id_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xb545(%rip), %rdi      # 0x11310
callq 0x62b0
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
callq 0x5eb0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x5e90
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
callq 0x5eb0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x5e90
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: vgteam[P]stream/./cpp/example.pb.h
// Function: Person::set_name(char const*)
inline void Person::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:Person.name)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, -0x59(%rbp)
cmpq $0x0, %rax
je 0x8b5e
jmp 0x8bb3
leaq 0x3798(%rip), %rdx      # 0xc2fd
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x3, %esi
movl $0x147, %ecx            # imm = 0x147
callq 0x4500
movq -0xb0(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x377f(%rip), %rsi      # 0xc310
callq 0x4520
movq %rax, -0xa8(%rbp)
jmp 0x8b9f
movq -0xa8(%rbp), %rsi
leaq -0x6d(%rbp), %rdi
callq 0x4430
jmp 0x8bb1
jmp 0x8bb3
testb $0x1, -0x59(%rbp)
jne 0x8bbb
jmp 0x8bc4
leaq -0x58(%rbp), %rdi
callq 0x4570
movq -0xa0(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x18, %rax
movq %rax, -0xd0(%rbp)
callq 0x5eb0
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4590
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x9160
jmp 0x8c3f
movq -0xa0(%rbp), %rdi
callq 0x5f90
movq %rax, -0xd8(%rbp)
jmp 0x8c54
movq -0xd8(%rbp), %rcx
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x5f10
jmp 0x8c77
leaq -0x90(%rbp), %rdi
callq 0x41f0
leaq -0x91(%rbp), %rdi
callq 0x4360
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x8cac
jmp 0x8cb5
leaq -0x58(%rbp), %rdi
callq 0x4570
jmp 0x8ce9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8cdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x41f0
leaq -0x91(%rbp), %rdi
callq 0x4360
movq -0x68(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vgteam[P]stream/./cpp/example.pb.h
// Function: Person::set_email(char const*)
inline void Person::set_email(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  email_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:Person.email)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, -0x59(%rbp)
cmpq $0x0, %rax
je 0x8d5e
jmp 0x8db3
leaq 0x3598(%rip), %rdx      # 0xc2fd
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x3, %esi
movl $0x1c0, %ecx            # imm = 0x1C0
callq 0x4500
movq -0xb0(%rbp), %rdi
movb $0x1, -0x59(%rbp)
leaq 0x357f(%rip), %rsi      # 0xc310
callq 0x4520
movq %rax, -0xa8(%rbp)
jmp 0x8d9f
movq -0xa8(%rbp), %rsi
leaq -0x6d(%rbp), %rdi
callq 0x4430
jmp 0x8db1
jmp 0x8db3
testb $0x1, -0x59(%rbp)
jne 0x8dbb
jmp 0x8dc4
leaq -0x58(%rbp), %rdi
callq 0x4570
movq -0xa0(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x2, %esi
movl %esi, (%rcx,%rdx,4)
addq $0x20, %rax
movq %rax, -0xd0(%rbp)
callq 0x5eb0
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4590
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x9160
jmp 0x8e3f
movq -0xa0(%rbp), %rdi
callq 0x5f90
movq %rax, -0xd8(%rbp)
jmp 0x8e54
movq -0xd8(%rbp), %rcx
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x5f10
jmp 0x8e77
leaq -0x90(%rbp), %rdi
callq 0x41f0
leaq -0x91(%rbp), %rdi
callq 0x4360
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x8eac
jmp 0x8eb5
leaq -0x58(%rbp), %rdi
callq 0x4570
jmp 0x8ee9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8edd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x41f0
leaq -0x91(%rbp), %rdi
callq 0x4360
movq -0x68(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d10
cmpq -0x18(%rbp), %rax
jb 0x9059
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x9d40
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9d10
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq %rax, %rsi
callq 0x9dd0
movb %al, -0x55(%rbp)
jmp 0x9026
movb -0x55(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa0c0
leaq -0x40(%rbp), %rdi
callq 0xa0e0
jmp 0x9059
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xa0e0
jmp 0x9064
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: davmac314[P]dinit/src/dinit-monitor.cc
// Function: split_command(char const*)
static std::vector<stringview> split_command(const char *cmd)
{
    using std::locale;
    using std::isspace;
    const locale &classic_loc = locale::classic();
    std::vector<stringview> result;

    const char *c = cmd;

    do {
        while (*c != '\0' && isspace(*c, classic_loc)) ++c;
        if (*c == '\0') break;
        const char *str = c;

        while (*c != '\0' && !isspace(*c, classic_loc)) {
            if (*c == '"') {
                ++c; // skip begin quote
                while (*c != '\0' && *c != '"') ++c;
            }
            ++c;
        }

        size_t len = c - str;

        result.emplace_back(stringview {str, len});
    } while (*c != '\0');

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x33f0
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9490
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4c7b
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x69(%rbp)
je 0x4ca9
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x94b0
movb %al, -0x6a(%rbp)
jmp 0x4ca1
movb -0x6a(%rbp), %al
movb %al, -0x69(%rbp)
jmp 0x4ca9
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x4cb2
jmp 0x4cda
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4c7b
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x6860
jmp 0x4dea
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4ceb
jmp 0x4dcd
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x6b(%rbp)
je 0x4d21
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
movq -0x18(%rbp), %rsi
callq 0x94b0
movb %al, -0x6c(%rbp)
jmp 0x4d19
movb -0x6c(%rbp), %al
xorb $-0x1, %al
movb %al, -0x6b(%rbp)
movb -0x6b(%rbp), %al
testb $0x1, %al
jne 0x4d2a
jmp 0x4d8d
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x4d7c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x6d(%rbp)
je 0x4d63
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
setne %al
movb %al, -0x6d(%rbp)
movb -0x6d(%rbp), %al
testb $0x1, %al
jne 0x4d6c
jmp 0x4d7a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4d42
jmp 0x4d7c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4cf3
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x94f0
jmp 0x4dbb
jmp 0x4dbd
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4c79
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4de0
movq -0x60(%rbp), %rdi
callq 0x6860
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/dinit-monitor.cc
// Function: load_service(int, cpbuffer<1024u>&, char const*, unsigned int*, service_state_t*)
static bool load_service(int socknum, cpbuffer_t &rbuffer, const char *name, handle_t *handle,
        service_state_t *state)
{
    // Load 'to' service:
    if (issue_load_service(socknum, name)) {
        return false;
    }

    wait_for_reply(rbuffer, socknum);

    if (check_load_reply(socknum, rbuffer, handle, state) != 0) {
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x5780
cmpl $0x0, %eax
je 0x4e44
movb $0x0, -0x1(%rbp)
jmp 0x4e73
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x6ec0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5850
cmpl $0x0, %eax
je 0x4e6f
movb $0x0, -0x1(%rbp)
jmp 0x4e73
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movb $0x1b, -0x13(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x5, %eax
jge 0x4ec0
movl $0x1, %edi
callq 0x3130
movq %rax, %rdi
leaq 0x10e99(%rip), %rsi     # 0x15d50
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movl -0x4(%rbp), %edi
leaq -0x13(%rbp), %rsi
movl $0x1, %edx
callq 0x6e30
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x6ec0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x64e0
movb %al, -0x14(%rbp)
cmpb $0x32, -0x14(%rbp)
je 0x4f0e
movl $0x1, %edi
callq 0x3130
movq %rax, %rdi
leaq 0x10e23(%rip), %rsi     # 0x15d28
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x66d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movw 0x9add(%rip), %ax       # 0xea23
movw %ax, -0x12(%rbp)
movl -0x4(%rbp), %edi
leaq -0x12(%rbp), %rsi
movl $0x2, %edx
callq 0x6e30
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x6ec0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x64e0
movb %al, -0x13(%rbp)
cmpb $0x4e, -0x13(%rbp)
je 0x4f98
movl $0x1, %edi
callq 0x3130
movq %rax, %rdi
leaq 0x10d99(%rip), %rsi     # 0x15d28
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movq $0x9, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
movl $0x9, %edx
callq 0x6480
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0x1, %edx
movl $0x8, %ecx
callq 0x6620
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x66d0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: davmac314[P]dinit/src/dinit-monitor.cc
// Function: main
int main(int argc, char **argv) {
    try {
        return dinit_monitor_main(argc, argv);
    }
    catch (std::bad_alloc &e) {
        std::cerr << "dinit-monitor: out of memory\n";
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x36a0
movl %eax, -0x2c(%rbp)
jmp 0x56f7
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x575c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5765
movq -0x18(%rbp), %rdi
callq 0x30d0
movq %rax, -0x28(%rbp)
movq 0x108c5(%rip), %rdi     # 0x15ff0
leaq 0x9193(%rip), %rsi      # 0xe8c5
callq 0x32a0
jmp 0x5739
callq 0x34c0
movl $0x1, -0x4(%rbp)
jmp 0x575c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x34c0
jmp 0x575a
jmp 0x5765
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3500
movq %rax, %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/dinit-monitor.cc
// Function: issue_load_service(int, char const*, bool)
static int issue_load_service(int socknum, const char *service_name, bool find_only = false)
{
    // Build buffer;
    srvname_len_t srvname_len = strlen(service_name);
    int bufsize = 3 + srvname_len;

    std::unique_ptr<char[]> ubuf(new char[bufsize]);
    auto buf = ubuf.get();

    buf[0] = (char)(find_only ? cp_cmd::FINDSERVICE : cp_cmd::LOADSERVICE);
    memcpy(buf + 1, &srvname_len, sizeof(srvname_len));
    memcpy(buf + 3, service_name, srvname_len);

    write_all_x(socknum, buf, bufsize);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movw %ax, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rdi
callq 0x3030
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9da0
movq -0x40(%rbp), %rdi
callq 0x9dd0
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movb $0x2, %cl
subb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movw -0x14(%rbp), %cx
movw %cx, 0x1(%rax)
movq -0x28(%rbp), %rdi
addq $0x3, %rdi
movq -0x10(%rbp), %rsi
movzwl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x3210
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x6e30
jmp 0x5816
leaq -0x20(%rbp), %rdi
callq 0x9e00
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9e00
movq -0x30(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/dinit-monitor.cc
// Function: check_load_reply(int, cpbuffer<1024u>&, unsigned int*, service_state_t*)
static int check_load_reply(int socknum, cpbuffer_t &rbuffer, handle_t *handle_p, service_state_t *state_p)
{
    using namespace std;

    cp_rply reply_pkt_h = (cp_rply)rbuffer[0];
    if (reply_pkt_h == cp_rply::SERVICERECORD) {
        fill_buffer_to(rbuffer, socknum, 2 + sizeof(*handle_p));
        rbuffer.extract((char *) handle_p, 2, sizeof(*handle_p));
        if (state_p) *state_p = static_cast<service_state_t>(rbuffer[1]);
        //target_state = static_cast<service_state_t>(rbuffer[2 + sizeof(handle)]);
        rbuffer.consume(3 + sizeof(*handle_p));
        return 0;
    }
    else if (reply_pkt_h == cp_rply::NOSERVICE) {
        return 1;
    }
    else {
        throw dinit_protocol_error();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x64e0
movb %al, -0x21(%rbp)
cmpb $0x3b, -0x21(%rbp)
jne 0x58d7
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
movl $0x6, %edx
callq 0x6520
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
movl $0x4, %ecx
callq 0x6620
cmpq $0x0, -0x20(%rbp)
je 0x58c0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x64e0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movl $0x7, %esi
callq 0x66d0
movl $0x0, -0x4(%rbp)
jmp 0x5903
cmpb $0x3c, -0x21(%rbp)
jne 0x58e6
movl $0x1, -0x4(%rbp)
jmp 0x5903
movl $0x1, %edi
callq 0x3130
movq %rax, %rdi
leaq 0x1042e(%rip), %rsi     # 0x15d28
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x8c98(%rip), %rdi      # 0xe8e3
callq 0x3360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5c7a
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3400
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, -0x20(%rbp)
jmp 0x5d46
testb $0x1, -0x11(%rbp)
je 0x5d39
leaq 0x8c6a(%rip), %rdi      # 0xe8f5
callq 0x3360
movq %rax, -0x30(%rbp)
leaq 0x8c6b(%rip), %rax      # 0xe906
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5cef
leaq 0x8c58(%rip), %rax      # 0xe905
movq %rax, -0x38(%rbp)
leaq 0x8c57(%rip), %rdi      # 0xe90f
callq 0x3360
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5ced
callq 0x3140
movl %eax, %edi
callq 0x3330
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x5ceb
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5ced
jmp 0x5cef
cmpq $0x0, -0x30(%rbp)
je 0x5d2d
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3400
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x3250
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3290
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, -0x20(%rbp)
jmp 0x5d37
movq $0x0, -0x8(%rbp)
jmp 0x5d4e
jmp 0x5d44
leaq 0x8cfd(%rip), %rax      # 0xea3d
movq %rax, -0x20(%rbp)
jmp 0x5d46
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/includes/dinit-client.h
// Function: fill_some(cpbuffer<1024u>&, int)
inline void fill_some(cpbuffer_t &buf, int fd)
{
    while(true) {
        int r = buf.fill(fd);
        if (r == 0) {
            throw cp_read_exception(0);
        }
        else if (r > 0) {
            return;
        }

        if (errno != EINTR) {
            throw cp_read_exception(errno);
        }

        // if EINTR, just try again
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xabd0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0xa35c
movl $0x4, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorl %esi, %esi
callq 0x6f50
jmp 0xa331
movq -0x28(%rbp), %rdi
leaq 0xba2c(%rip), %rsi      # 0x15d68
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0xa3c8
cmpl $0x0, -0x10(%rbp)
jle 0xa368
addq $0x40, %rsp
popq %rbp
retq
jmp 0xa36a
callq 0x3040
cmpl $0x4, (%rax)
je 0xa3c3
movl $0x4, %edi
callq 0x3130
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
callq 0x3040
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x6f50
jmp 0xa398
movq -0x38(%rbp), %rdi
leaq 0xb9c5(%rip), %rsi      # 0x15d68
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31d0
jmp 0xa3c8
jmp 0xa2ff
movq -0x18(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1aabd(%rip), %rdi     # 0x1cfd0
leaq 0xfaea(%rip), %rsi      # 0x12004
callq 0x2200
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x1aa8b(%rip), %rsi     # 0x1cfc0
callq 0x2240
movq 0x1aa8f(%rip), %rdi     # 0x1cfd0
leaq 0xface(%rip), %rsi      # 0x12016
callq 0x2200
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x2340
movq %rax, %rdi
leaq 0xfab9(%rip), %rsi      # 0x1201e
callq 0x2200
movq %rax, %rdi
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x2390
movq %rax, %rdi
leaq 0xfc17(%rip), %rsi      # 0x1219c
callq 0x2200
movq %rax, %rdi
movq 0x1aa2c(%rip), %rsi     # 0x1cfc0
callq 0x2240
movq 0x1aa30(%rip), %rdi     # 0x1cfd0
leaq 0xfa79(%rip), %rsi      # 0x12020
callq 0x2200
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2bf0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x2090
movq %rax, %rdi
movq 0x1a9ed(%rip), %rsi     # 0x1cfc0
callq 0x2240
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2bf0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x264e
movq 0x1a9c9(%rip), %rdi     # 0x1cfd0
leaq 0xfa1e(%rip), %rsi      # 0x1202c
callq 0x2200
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0x2c10
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x1a982(%rip), %rsi     # 0x1cfc0
callq 0x2240
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25df
movq 0x1a97b(%rip), %rdi     # 0x1cfd0
leaq 0xf9db(%rip), %rsi      # 0x12037
callq 0x2200
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x1a945(%rip), %rsi     # 0x1cfc0
callq 0x2240
movq 0x1a949(%rip), %rdi     # 0x1cfd0
movq 0x1a932(%rip), %rsi     # 0x1cfc0
callq 0x2240
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2bf0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x26df
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movslq -0x10(%rbp), %rsi
callq 0x2c10
movq (%rax), %rdi
callq 0x2500
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x269a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)