LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/sha256.c
// Function: sha256PadMsg
static void sha256PadMsg(SHA256Context *ctx, uint8_t pad_byte)
{
    /*
     * Check to see if the current message block is too small to hold
     * the initial padding bits and length.  If so, we will pad the
     * block, process it, and then continue padding into a second
     * block.
     */

    if(ctx->msg_block_idx >= (SHA256_Message_Block_Size - 8)){
        ctx->msg_block[ctx->msg_block_idx++] = pad_byte;
        while(ctx->msg_block_idx < SHA256_Message_Block_Size)
            ctx->msg_block[ctx->msg_block_idx++] = 0;
        sha256Process(ctx);
    } else
        ctx->msg_block[ctx->msg_block_idx++] = 0;

    /* Store the msg len as the last 8 octets */
    ctx->msg_block[56] = (uint32_t)(ctx->hl >> 24);
    ctx->msg_block[57] = (uint32_t)(ctx->hl >> 16);
    ctx->msg_block[58] = (uint32_t)(ctx->hl >> 8);
    ctx->msg_block[59] = (uint32_t)(ctx->hl);
    ctx->msg_block[60] = (uint32_t)(ctx->ll >> 24);
    ctx->msg_block[61] = (uint32_t)(ctx->ll >> 16);
    ctx->msg_block[62] = (uint32_t)(ctx->ll >> 8);
    ctx->msg_block[63] = (uint32_t)(ctx->ll);

    sha256Process(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movswl 0x28(%rax), %eax
cmpl $0x38, %eax
jl 0x1afb
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movw 0x28(%rsi), %cx
movw %cx, %di
addw $0x1, %di
movw %di, 0x28(%rsi)
movswq %cx, %rcx
movb %dl, 0x2a(%rax,%rcx)
movq -0x8(%rbp), %rax
movswl 0x28(%rax), %eax
cmpl $0x40, %eax
jge 0x1af0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movw 0x28(%rdx), %cx
movw %cx, %si
addw $0x1, %si
movw %si, 0x28(%rdx)
movswq %cx, %rcx
movb $0x0, 0x2a(%rax,%rcx)
jmp 0x1ac1
movq -0x8(%rbp), %rdi
callq 0x13d0
jmp 0x1b1b
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rdx
movw 0x28(%rdx), %cx
movw %cx, %si
addw $0x1, %si
movw %si, 0x28(%rdx)
movswq %cx, %rcx
movb $0x0, 0x2a(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x62(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x63(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x64(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x65(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x66(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x67(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x68(%rax)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x69(%rax)
movq -0x8(%rbp), %rdi
callq 0x13d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/main.c
// Function: help
void help()
{
  printf("\t\t\t...HELP...\t\t\t\n");
  printf("usage: ./sha -i <filename> -h <hashing_val>\n");
  printf("\t-i  input file\n");
  printf("\t-h  256/512 hashing value\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x545(%rip), %rdi       # 0x2110
movb $0x0, %al
callq 0x1060
leaq 0x549(%rip), %rdi       # 0x2122
movb $0x0, %al
callq 0x1060
leaq 0x568(%rip), %rdi       # 0x214f
movb $0x0, %al
callq 0x1060
leaq 0x56b(%rip), %rdi       # 0x2160
movb $0x0, %al
callq 0x1060
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/main.c
// Function: init_sha_256
void init_sha_256(char *infile)
{
  SHA256Context ctx;
  char msg[1000];
  uint8_t msgDigest[SHA256_Hash_Size];
  FILE *fp = fopen(infile, "r+");
  if(NULL == fp){
    printf("error: file doesn't exist.\n");
    return;
  }
  sha256Init(&ctx);
  while(!feof(fp)){
    fscanf(fp, "%s", msg);
    sha256Input(&ctx, (uint8_t *)msg, strlen(msg));
  }
  sha256FinalizeBits(&ctx, 0x80, 3);
  sha256Result(&ctx, msgDigest);
    
  for(int i = 0; i < SHA256_Hash_Size; ++i){
    printf("%.2x ", msgDigest[i]);
  }
  printf("\n");
  fclose(fp);  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp            # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x562(%rip), %rsi       # 0x217c
callq 0x1080
movq %rax, -0x498(%rbp)
xorl %eax, %eax
cmpq -0x498(%rbp), %rax
jne 0x1c44
leaq 0x547(%rip), %rdi       # 0x217f
movb $0x0, %al
callq 0x1060
jmp 0x1d2f
leaq -0x7c(%rbp), %rdi
callq 0x11b0
movq -0x498(%rbp), %rdi
callq 0x1070
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c67
jmp 0x1cb1
movq -0x498(%rbp), %rdi
leaq -0x470(%rbp), %rdx
leaq 0x51f(%rip), %rsi       # 0x219b
movb $0x0, %al
callq 0x1030
leaq -0x470(%rbp), %rax
movq %rax, -0x4a8(%rbp)
leaq -0x470(%rbp), %rdi
callq 0x1050
movq -0x4a8(%rbp), %rsi
movl %eax, %edx
leaq -0x7c(%rbp), %rdi
callq 0x1270
jmp 0x1c4d
leaq -0x7c(%rbp), %rdi
movl $0x80, %esi
movl $0x3, %edx
callq 0x1820
leaq -0x490(%rbp), %rsi
leaq -0x7c(%rbp), %rdi
callq 0x19c0
movl $0x0, -0x49c(%rbp)
cmpl $0x20, -0x49c(%rbp)
jge 0x1d15
movslq -0x49c(%rbp), %rax
movzbl -0x490(%rbp,%rax), %esi
leaq 0x4a1(%rip), %rdi       # 0x219e
movb $0x0, %al
callq 0x1060
movl -0x49c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x49c(%rbp)
jmp 0x1cde
leaq 0x404(%rip), %rdi       # 0x2120
movb $0x0, %al
callq 0x1060
movq -0x498(%rbp), %rdi
callq 0x1040
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dubeyalok7[P]crypto-algo/sha/main.c
// Function: main
int main(int argc, char *argv[])
{
  int opt, hash_val = 0;
  extern char *optarg;
  char *infile;
  if(argc<5){
    help();
    return 0;
  }
  while((opt = getopt(argc, argv, "i:h:")) != -1){
    switch (opt)
    {
      case 'i':
        infile = optarg;
        break;
      case 'h':
        hash_val = atoi(optarg);      
        break;
    }
  }
  if(256 == hash_val){
    init_sha_256(infile);
  } else if(512 == hash_val){
    init_sha_512(infile);
  }  
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x1d84
callq 0x1bc0
movl $0x0, -0x4(%rbp)
jmp 0x1e0d
jmp 0x1d86
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x410(%rip), %rdx       # 0x21a4
callq 0x1090
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x1ddc
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x68, %eax
je 0x1dc8
jmp 0x1dae
movl -0x24(%rbp), %eax
subl $0x69, %eax
jne 0x1dda
jmp 0x1db8
movq 0x2221(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1dda
movq 0x2211(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movl %eax, -0x18(%rbp)
jmp 0x1d86
movl $0x100, %eax            # imm = 0x100
cmpl -0x18(%rbp), %eax
jne 0x1df1
movq -0x20(%rbp), %rdi
callq 0x1c00
jmp 0x1e06
movl $0x200, %eax            # imm = 0x200
cmpl -0x18(%rbp), %eax
jne 0x1e04
movq -0x20(%rbp), %rdi
callq 0x1d40
jmp 0x1e06
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_read
int rd_net_read(pNetwork_t pNetwork, void *connect, char *buffer, int len, int timeout_ms)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        if (NULL != connect) {
            return ws_nopoll_read(connect, buffer, len, timeout_ms);
        } else {
            return ws_nopoll_read(pNetwork->handle, buffer, len, timeout_ms);
        }
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2761
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2745
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x2cf0
movl %eax, -0x4(%rbp)
jmp 0x2792
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x2cf0
movl %eax, -0x4(%rbp)
jmp 0x2792
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x8893(%rip), %rsi      # 0xb004
leaq 0x8892(%rip), %rdx      # 0xb00a
movl $0xe, %ecx
leaq 0x88a0(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_write
int rd_net_write(pNetwork_t pNetwork, void *connect, const char *buffer, int len, int timeout_ms)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        if (NULL != connect) {
            return ws_nopoll_write(connect, buffer, len, timeout_ms);
        } else {
            return ws_nopoll_write(pNetwork->handle, buffer, len, timeout_ms);
        }
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2801
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x27e5
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x2d40
movl %eax, -0x4(%rbp)
jmp 0x2832
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0x2d40
movl %eax, -0x4(%rbp)
jmp 0x2832
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x87f3(%rip), %rsi      # 0xb004
leaq 0x87f2(%rip), %rdx      # 0xb00a
movl $0x1c, %ecx
leaq 0x8800(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_destroy
int rd_net_destroy(pNetwork_t pNetwork)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        return ws_nopoll_destroy(pNetwork->handle);
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2868
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2ea0
movl %eax, -0x4(%rbp)
jmp 0x2899
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x878c(%rip), %rsi      # 0xb004
leaq 0x878b(%rip), %rdx      # 0xb00a
movl $0x26, %ecx
leaq 0x8799(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_connect
int rd_net_connect(pNetwork_t pNetwork)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        pNetwork->handle = (void *)ws_nopoll_connect(pNetwork->debug_on, pNetwork->host, pNetwork->port, 
                                pNetwork->get_url, pNetwork->tls_on, pNetwork->ca_crt);
        if (NULL != pNetwork->handle) {
            return 0;
        }
        return -1;
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2923
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x30(%rax), %r8d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %r9
callq 0x2f10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
je 0x291a
movl $0x0, -0x4(%rbp)
jmp 0x2954
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2954
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x86d1(%rip), %rsi      # 0xb004
leaq 0x86d0(%rip), %rdx      # 0xb00a
movl $0x35, %ecx
leaq 0x86de(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_listener
int rd_net_listener(pNetwork_t pNetwork)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        pNetwork->handle = (void *)ws_nopoll_listener(pNetwork->debug_on, pNetwork->host, pNetwork->port, 
                                pNetwork->tls_on, pNetwork->ca_crt, pNetwork->pri_key);
        if (NULL != pNetwork->handle) {
            return 0;
        }
        return -1;
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x29d2
movq -0x10(%rbp), %rax
movl 0x34(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %r9
callq 0x3210
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x38(%rcx), %rax
je 0x29c9
movl $0x0, -0x4(%rbp)
jmp 0x2a03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2a03
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x8622(%rip), %rsi      # 0xb004
leaq 0x8621(%rip), %rdx      # 0xb00a
movl $0x44, %ecx
leaq 0x862f(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_set_on_msg
int rd_net_set_on_msg(pNetwork_t pNetwork, MessageHandler on_message)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        return ws_nopoll_set_on_msg(pNetwork->handle, (noPollOnMessageHandler)on_message);
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2a40
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x35b0
movl %eax, -0x4(%rbp)
jmp 0x2a71
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x85b4(%rip), %rsi      # 0xb004
leaq 0x85b3(%rip), %rdx      # 0xb00a
movl $0x4e, %ecx
leaq 0x85c1(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_set_on_ready
int rd_net_set_on_ready(pNetwork_t pNetwork, ActionHandler on_ready)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        return ws_nopoll_set_on_ready(pNetwork->handle, (noPollActionHandler)on_ready);
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2ab0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x34f0
movl %eax, -0x4(%rbp)
jmp 0x2ae1
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x8544(%rip), %rsi      # 0xb004
leaq 0x8543(%rip), %rdx      # 0xb00a
movl $0x58, %ecx
leaq 0x8551(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_accept
void *rd_net_accept(pNetwork_t pNetwork)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        return ws_nopoll_accept(pNetwork->handle);
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2b19
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3670
movq %rax, -0x8(%rbp)
jmp 0x2b4b
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x84db(%rip), %rsi      # 0xb004
leaq 0x84da(%rip), %rdx      # 0xb00a
movl $0x62, %ecx
leaq 0x84e8(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_get_conn_info
int rd_net_get_conn_info (pNetwork_t pNetwork, void *connect, ConnectInfo_t *connInfo)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        if (NULL != connect) {
            return ws_nopoll_get_conn_info(connect, connInfo);
        } else {
            return ws_nopoll_get_conn_info(pNetwork->handle, connInfo);
        }
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2bae
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2b98
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3770
movl %eax, -0x4(%rbp)
jmp 0x2bdf
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x3770
movl %eax, -0x4(%rbp)
jmp 0x2bdf
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x8446(%rip), %rsi      # 0xb004
leaq 0x8445(%rip), %rdx      # 0xb00a
movl $0x70, %ecx
leaq 0x8453(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_loop_wait
int rd_net_loop_wait (pNetwork_t pNetwork)
{
    if (RD_NET_WEBSOCKET == pNetwork->type) {
        return ws_nopoll_loop_wait(pNetwork->handle);
    } else {
        log_debug("unsupport connect type: %d ", pNetwork->type);
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
jne 0x2c18
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3440
movl %eax, -0x4(%rbp)
jmp 0x2c49
movq -0x10(%rbp), %rax
movl (%rax), %r9d
xorl %edi, %edi
leaq 0x83dc(%rip), %rsi      # 0xb004
leaq 0x83db(%rip), %rdx      # 0xb00a
movl $0x7a, %ecx
leaq 0x83e9(%rip), %r8       # 0xb024
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/rd_net.c
// Function: rd_net_init
int rd_net_init(pNetwork_t pNetwork, RD_NET_TYPE_T type, const int debug_on, 
                  const char *host, const char *port, const char *get_url,
                  const int tls_on, const char *ca_crt, const char *pri_key)
{
    pNetwork->type = type;
    pNetwork->debug_on = debug_on;
    pNetwork->host = host;
    pNetwork->port = port;
    pNetwork->get_url = get_url;
    pNetwork->tls_on = tls_on;
    pNetwork->ca_crt = ca_crt;
    pNetwork->pri_key = pri_key;
    pNetwork->handle = NULL;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl 0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq 0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_write
int ws_nopoll_write(void *handle, const char *buffer, int len, int timeout_ms)
{
    noPollConn *conn = (noPollConn *)handle;
    int tries = 0;
    int bytes_written = 0;

    if ((NULL != buffer) && (len > 0)) {
        bytes_written = nopoll_conn_send_binary (conn, buffer, len);
        if (bytes_written == len) {
            //log_debug ("send all. ");
            return bytes_written;
        }

        while (tries < 5 && errno == NOPOLL_EWOULDBLOCK 
          && nopoll_conn_pending_write_bytes (conn) > 0) {
            nopoll_sleep (10000); 
            if (0 == nopoll_conn_complete_pending_write (conn)) {
                log_debug ("send complete. ");
                return len;
            }
            tries++;
        }
        log_debug ("send len: %d, try: %d. ", bytes_written, tries);
        return  bytes_written;
    } else {
        log_debug ("ERROR: content is NULL or len <= 0 ");
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2e6c
cmpl $0x0, -0x1c(%rbp)
jle 0x2e6c
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2450
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2da9
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e96
jmp 0x2dab
xorl %eax, %eax
cmpl $0x5, -0x2c(%rbp)
movb %al, -0x31(%rbp)
jge 0x2dda
callq 0x23e0
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
movb %al, -0x31(%rbp)
jne 0x2dda
movq -0x28(%rbp), %rdi
callq 0x2180
cmpl $0x0, %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2de3
jmp 0x2e37
movl $0x2710, %edi           # imm = 0x2710
callq 0x25a0
movq -0x28(%rbp), %rdi
callq 0x2230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2e29
xorl %edi, %edi
leaq 0x81fd(%rip), %rsi      # 0xb004
leaq 0x8232(%rip), %rdx      # 0xb040
movl $0x30, %ecx
leaq 0x8243(%rip), %r8       # 0xb05d
movb $0x0, %al
callq 0x4f90
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e96
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2dab
movl -0x30(%rbp), %r9d
movl -0x2c(%rbp), %eax
xorl %edi, %edi
leaq 0x81bd(%rip), %rsi      # 0xb004
leaq 0x81f2(%rip), %rdx      # 0xb040
movl $0x35, %ecx
leaq 0x8213(%rip), %r8       # 0xb06d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4f90
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2e96
xorl %edi, %edi
leaq 0x818f(%rip), %rsi      # 0xb004
leaq 0x81c4(%rip), %rdx      # 0xb040
movl $0x38, %ecx
leaq 0x81fd(%rip), %r8       # 0xb085
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_destroy
int ws_nopoll_destroy(void *handle)
{
    noPollConn *conn = (noPollConn *)handle;
    noPollCtx *ctx = NULL;

	/* finish connection */
	if (NULL != conn) {
        ctx = nopoll_conn_ctx(conn);
    	nopoll_conn_close(conn);
	}
	
	/* finish */
	if (NULL != ctx) {
    	nopoll_loop_stop(ctx);
        nopoll_ctx_unref(ctx);
	}

	/* call to cleanup */
	nopoll_cleanup_library ();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x2eda
movq -0x10(%rbp), %rdi
callq 0x2040
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2060
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x2ef4
movq -0x18(%rbp), %rdi
callq 0x2540
movq -0x18(%rbp), %rdi
callq 0x25d0
callq 0x21f0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_loop_wait
int ws_nopoll_loop_wait(void *handle)
{
    noPollConn *conn = (noPollConn *)handle;
    noPollCtx *ctx = NULL;

    if (NULL == conn) {
        log_debug("ERROR: conn is NULL ");
        return -1;
    }

    ctx = nopoll_conn_ctx(conn);
    if (NULL == ctx) {
        log_debug("ERROR: ctx is NULL ");
        return -1;
    }

    nopoll_loop_wait(ctx, 0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x3490
xorl %edi, %edi
leaq 0x7b97(%rip), %rsi      # 0xb004
leaq 0x7bcc(%rip), %rdx      # 0xb040
movl $0xd8, %ecx
leaq 0x7e50(%rip), %r8       # 0xb2d0
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x34e5
movq -0x18(%rbp), %rdi
callq 0x2040
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x34d1
xorl %edi, %edi
leaq 0x7b56(%rip), %rsi      # 0xb004
leaq 0x7b8b(%rip), %rdx      # 0xb040
movl $0xde, %ecx
leaq 0x7e24(%rip), %r8       # 0xb2e5
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x34e5
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_set_on_ready
int ws_nopoll_set_on_ready(void *handle, noPollActionHandler on_ready)
{
    noPollConn *conn = (noPollConn *)handle;
    noPollCtx *ctx = NULL;

    if (NULL == conn) {
        log_debug("ERROR: conn is NULL ");
        return -1;
    }

    ctx = nopoll_conn_ctx(conn);
    if (NULL == ctx) {
        log_debug("ERROR: ctx is NULL ");
        return -1;
    }

    /* set on connect ready */
	if (NULL != on_ready) {
    	nopoll_ctx_set_on_ready (ctx, on_ready, NULL);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x3544
xorl %edi, %edi
leaq 0x7ae3(%rip), %rsi      # 0xb004
leaq 0x7b18(%rip), %rdx      # 0xb040
movl $0xec, %ecx
leaq 0x7d9c(%rip), %r8       # 0xb2d0
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35a5
movq -0x20(%rbp), %rdi
callq 0x2040
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x3585
xorl %edi, %edi
leaq 0x7aa2(%rip), %rsi      # 0xb004
leaq 0x7ad7(%rip), %rdx      # 0xb040
movl $0xf2, %ecx
leaq 0x7d70(%rip), %r8       # 0xb2e5
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x35a5
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x359e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_set_on_msg
int ws_nopoll_set_on_msg(void *handle, noPollOnMessageHandler on_message)
{
    noPollConn *conn = (noPollConn *)handle;
    noPollCtx *ctx = NULL;

    if (NULL == conn) {
        log_debug("ERROR: conn is NULL ");
        return -1;
    }

    ctx = nopoll_conn_ctx(conn);
    if (NULL == ctx) {
        log_debug("ERROR: ctx is NULL ");
        return -1;
    }

	/* set on message received */
	if (NULL != on_message) {
    	nopoll_ctx_set_on_msg (ctx, on_message, NULL);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x3604
xorl %edi, %edi
leaq 0x7a23(%rip), %rsi      # 0xb004
leaq 0x7a58(%rip), %rdx      # 0xb040
movl $0x104, %ecx            # imm = 0x104
leaq 0x7cdc(%rip), %r8       # 0xb2d0
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3665
movq -0x20(%rbp), %rdi
callq 0x2040
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x3645
xorl %edi, %edi
leaq 0x79e2(%rip), %rsi      # 0xb004
leaq 0x7a17(%rip), %rdx      # 0xb040
movl $0x10a, %ecx            # imm = 0x10A
leaq 0x7cb0(%rip), %r8       # 0xb2e5
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3665
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x365e
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2480
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_accept
noPollConn *ws_nopoll_accept(void *handle)
{
    noPollConn *master = (noPollConn *)handle;
    noPollConn *conn = NULL;
    noPollCtx *ctx = NULL;

    if (NULL == master) {
        log_debug("ERROR: master conn is NULL ");
        return NULL;
    }

    ctx = nopoll_conn_ctx(master);
    if (NULL == ctx) {
        log_debug("ERROR: ctx is NULL ");
        return NULL;
    }

    conn = nopoll_conn_accept(ctx, master);
	if (!nopoll_conn_is_ok (conn)) {
		log_debug("ERROR: expected to find proper listener status (connection accepted), but found failure.. ");
		return NULL;
	}

	return conn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x36cc
xorl %edi, %edi
leaq 0x795f(%rip), %rsi      # 0xb004
leaq 0x7994(%rip), %rdx      # 0xb040
movl $0x11d, %ecx            # imm = 0x11D
leaq 0x7c41(%rip), %r8       # 0xb2f9
movb $0x0, %al
callq 0x4f90
movq $0x0, -0x8(%rbp)
jmp 0x3762
movq -0x18(%rbp), %rdi
callq 0x2040
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x370e
xorl %edi, %edi
leaq 0x791a(%rip), %rsi      # 0xb004
leaq 0x794f(%rip), %rdx      # 0xb040
movl $0x123, %ecx            # imm = 0x123
leaq 0x7be8(%rip), %r8       # 0xb2e5
movb $0x0, %al
callq 0x4f90
movq $0x0, -0x8(%rbp)
jmp 0x3762
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2270
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2310
cmpl $0x0, %eax
jne 0x375a
xorl %edi, %edi
leaq 0x78ce(%rip), %rsi      # 0xb004
leaq 0x7903(%rip), %rdx      # 0xb040
movl $0x129, %ecx            # imm = 0x129
leaq 0x7bcc(%rip), %r8       # 0xb315
movb $0x0, %al
callq 0x4f90
movq $0x0, -0x8(%rbp)
jmp 0x3762
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/connectivity/ws_nopoll.c
// Function: ws_nopoll_get_conn_info
int ws_nopoll_get_conn_info(void *handle, ConnectInfo_t *connInfo)
{
    if (NULL == connInfo) {
        log_debug("ERROR: connInfo is NULL ");
        return -1;
    }

    noPollConn *conn = (noPollConn *)handle;
    if (NULL != conn) {
        connInfo->sockfd = (int) nopoll_conn_socket(conn);
        connInfo->host = nopoll_conn_host(conn);
        connInfo->port = nopoll_conn_port(conn);
        connInfo->origin = nopoll_conn_get_origin(conn);
        //printf("----> origin:  %s\n", connInfo->origin);
        connInfo->get_url = nopoll_conn_get_requested_url(conn);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x37b4
xorl %edi, %edi
leaq 0x7873(%rip), %rsi      # 0xb004
leaq 0x78a8(%rip), %rdx      # 0xb040
movl $0x133, %ecx            # imm = 0x133
leaq 0x7bcc(%rip), %r8       # 0xb370
movb $0x0, %al
callq 0x4f90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x382c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x3825
movq -0x20(%rbp), %rdi
callq 0x2410
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x2200
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdi
callq 0x2030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
callq 0x22b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/json/json_parser.c
// Function: json_get_object
char* json_get_object(int type, char* str) {
    char* pos = 0;
    char ch = (type == JOBJECT) ? '{' : '[';
    while (str != 0 && *str != 0) {
        if (*str == ' ') {
            str++;
            continue;
        }
        pos = (*str == ch) ? str : 0;
        break;
    }
    return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x4(%rbp), %edx
movl $0x5b, %eax
movl $0x7b, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movb %al, -0x19(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1a(%rbp)
je 0x3885
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x388e
jmp 0x38d1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x38a8
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3869
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x38c1
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x38c9
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x38c9
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/json/json_parser.c
// Function: json_parse_name_value
int json_parse_name_value(char *p_cJsonStr, int iStrLen, json_parse_cb pfnCB, void *p_CBData)
{
    char *pos=0, *key=0, *val=0;
    int klen=0, vlen=0, vtype=0;
    char last_char=0;
    int ret = JSON_RESULT_ERR;

    if (p_cJsonStr==NULL || iStrLen==0 || pfnCB==NULL)
        return ret;

    backup_json_str_last_char(p_cJsonStr, iStrLen, last_char);

    json_object_for_each_kv(p_cJsonStr, pos, key, klen, val, vlen, vtype) {
        if (key && klen && val && vlen) {
            ret = JSON_RESULT_OK;
            if (JSON_PARSE_FINISH == pfnCB(key, klen, val, vlen, vtype, p_CBData)) {	//catch the ball
                break;
            }
        }
    }

    restore_json_str_last_char(p_cJsonStr, iStrLen, last_char);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movb $0x0, -0x4d(%rbp)
movl $0xffffffff, -0x54(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x10(%rbp)
je 0x3dc3
cmpl $0x0, -0x14(%rbp)
je 0x3dc3
cmpq $0x0, -0x20(%rbp)
jne 0x3dce
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eb9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x4d(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x3840
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x55(%rbp)
je 0x3e4b
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x55(%rbp)
je 0x3e4b
movq -0x30(%rbp), %rsi
movl $0x1, %edi
leaq -0x38(%rbp), %rdx
leaq -0x44(%rbp), %rcx
leaq -0x40(%rbp), %r8
leaq -0x48(%rbp), %r9
leaq -0x4c(%rbp), %rax
movq %rax, (%rsp)
callq 0x38e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x3e54
jmp 0x3ea5
cmpq $0x0, -0x38(%rbp)
je 0x3ea0
cmpl $0x0, -0x44(%rbp)
je 0x3ea0
cmpq $0x0, -0x40(%rbp)
je 0x3ea0
cmpl $0x0, -0x48(%rbp)
je 0x3ea0
movl $0x0, -0x54(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movl -0x48(%rbp), %ecx
movl -0x4c(%rbp), %r8d
movq -0x28(%rbp), %r9
callq *%rax
movl %eax, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
jne 0x3e9e
jmp 0x3ea5
jmp 0x3ea0
jmp 0x3dfa
movb -0x4d(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/json/json_parser.c
// Function: json_get_value_by_name_cb
int json_get_value_by_name_cb(char *p_cName, int iNameLen, char *p_cValue, int iValueLen, int iValueType, void *p_CBData)
{
#if(JSON_DEBUG == 1)
    int i;
    if (p_cName) {
        json_debug("\nName:\n  ");
        for (i = 0; i < iNameLen; i++)
            json_debug("%c", *(p_cName + i));
    }

    if (p_cValue) {
        json_debug("\nValue:\n  ");
        for (i = 0; i < iValueLen; i++)
            json_debug("%c", *(p_cValue + i));
        json_debug("\n");
    }
#endif

    JSON_NV *p_stNameValue = (JSON_NV *) p_CBData;
    if (!strncmp(p_cName, p_stNameValue->pN, p_stNameValue->nLen)) {
        p_stNameValue->pV = p_cValue;
        p_stNameValue->vLen = iValueLen;
        p_stNameValue->vType = iValueType;
        return JSON_PARSE_FINISH;
    } else {
        return JSON_PARSE_OK;
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x38(%rbp), %rax
movslq (%rax), %rdx
callq 0x2130
cmpl $0x0, %eax
jne 0x3f3c
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x28(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x3f43
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/json/json_parser.c
// Function: json_get_value_by_name
char *json_get_value_by_name(char *p_cJsonStr, int iStrLen, char *p_cName, int *p_iValueLen, int *p_iValueType)
{
    JSON_NV stNV = { 0, 0, 0, 0 };
    stNV.pN = p_cName;
    stNV.nLen = strlen(p_cName);
    if (JSON_RESULT_OK == json_parse_name_value(p_cJsonStr, iStrLen, json_get_value_by_name_cb, (void *)&stNV)) {
        if (p_iValueLen)
            *p_iValueLen = stNV.vLen;
        if (p_iValueType)
            *p_iValueType = stNV.vType;
    }
    return stNV.pV;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2090
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0xcd(%rip), %rdx       # 0x3ed0
leaq -0x48(%rbp), %rcx
callq 0x3d60
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3fd0
cmpq $0x0, -0x20(%rbp)
je 0x3fbe
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x3fce
movl -0x40(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x3fd0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/json/json_parser.c
// Function: json_get_array_size
int json_get_array_size(char *json_str, int str_len)
{
    char *pos, *entry;

    char last_char = 0;
    backup_json_str_last_char(json_str, str_len, last_char);

    int len, type, size = 0;
    json_array_for_each_entry(json_str, pos, entry, len, type){
        size++;
    }
    restore_json_str_last_char(json_str, str_len, last_char);

    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movl $0x2, %edi
callq 0x3840
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
je 0x407e
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x407e
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %rax
movq %rcx, %rdx
movq %rax, (%rsp)
callq 0x38e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4087
jmp 0x4092
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4026
movb -0x21(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/misc/misc.c
// Function: dump_hex
void dump_hex(char *p , int len)
{
    int i = 0;

    for(i = 0; i < len; i++){
        printf("0x%x ",(unsigned char)p[i]) ; 
        if(i != 0 && i % 10 == 0)
            printf("\n");
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4120
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x72c1(%rip), %rdi      # 0xb3a9
movb $0x0, %al
callq 0x2080
cmpl $0x0, -0x10(%rbp)
je 0x4113
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4113
leaq 0x7c89(%rip), %rdi      # 0xbd95
movb $0x0, %al
callq 0x2080
jmp 0x4115
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x40cd
leaq 0x7c6e(%rip), %rdi      # 0xbd95
movb $0x0, %al
callq 0x2080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/misc/misc.c
// Function: get_dev_ip
int get_dev_ip(char *buf, int size)
{
    FILE *fp = NULL;
    char bufTmp[256];
    int len = 0, j = 0, i = 0;

    if (NULL == buf || size < 256) {
        return 0;
    }
    
    fp = popen(SHELL_GET_IP, "r");
    if(fp == NULL)
        return 0;

    memset(buf, 0x0, size);
    memset(bufTmp, 0x0, sizeof(bufTmp));
    fgets(bufTmp, sizeof(bufTmp), fp);

    for(i = 0; i < strlen(bufTmp); i++) {
        if (bufTmp[i] != '[' && bufTmp[i] != ']') {
            buf[j] = bufTmp[i];
            j++;
        }
    }
    len = strlen(buf);
    if(len > 0) {
        if (buf[len - 1] == '\n' || buf[len - 1] == '\r') {
            buf[len - 1] = '\0';
        }
    }

    pclose(fp);

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x124(%rbp)
movl $0x0, -0x128(%rbp)
movl $0x0, -0x12c(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x4189
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x4195
movl $0x0, -0x4(%rbp)
jmp 0x4304
leaq 0x7213(%rip), %rdi      # 0xb3af
leaq 0x76df(%rip), %rsi      # 0xb882
callq 0x2550
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x41bf
movl $0x0, -0x4(%rbp)
jmp 0x4304
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x2090
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2090
leaq -0x120(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x21d0
movl $0x0, -0x12c(%rbp)
movslq -0x12c(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x2260
movq %rax, %rcx
movq -0x138(%rbp), %rax
cmpq %rcx, %rax
jae 0x4292
movslq -0x12c(%rbp), %rax
movsbl -0x120(%rbp,%rax), %eax
cmpl $0x5b, %eax
je 0x427c
movslq -0x12c(%rbp), %rax
movsbl -0x120(%rbp,%rax), %eax
cmpl $0x5d, %eax
je 0x427c
movslq -0x12c(%rbp), %rax
movb -0x120(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movslq -0x128(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0x427e
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x4200
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x124(%rbp)
cmpl $0x0, -0x124(%rbp)
jle 0x42f2
movq -0x10(%rbp), %rax
movl -0x124(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x42dc
movq -0x10(%rbp), %rax
movl -0x124(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x42f0
movq -0x10(%rbp), %rax
movl -0x124(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x42f2
movq -0x20(%rbp), %rdi
callq 0x2290
movl -0x124(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/misc/misc.c
// Function: rand_string_alloc
char* rand_string_alloc(size_t size)
{
    char *s = malloc(size + 1);
    if (s) {
        _rand_string(s, size);
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x2140
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4341
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4350
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xiaowenhuyuehu[P]remote_access/src/utility/misc/misc.c
// Function: rand_string
static char *_rand_string(char *str, size_t size)
{
    const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    if (size) {
        --size;
        size_t n = 0;
        for (n = 0; n < size; n++) {
            int key = rand() % (int) (sizeof charset - 1);
            str[n] = charset[key];
        }
        str[size] = '\0';
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0x7075(%rip), %rsi      # 0xb3e0
movl $0x3f, %edx
callq 0x2570
cmpq $0x0, -0x10(%rbp)
je 0x43df
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x43d3
callq 0x2510
movl $0x3e, %ecx
cltd
idivl %ecx
movl %edx, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movb -0x50(%rbp,%rax), %dl
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x4398
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)