LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/jid.c
// Function: xmpp_jid_node
char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid)
{
    char *result = NULL;
    const char *c;

    c = strchr(jid, '@');
    if (c != NULL) {
	result = xmpp_alloc(ctx, (c-jid) + 1);
	if (result != NULL) {
	    memcpy(result, jid, (c-jid));
	    result[c-jid] = '\0';
	}
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8f51
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x6680
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8f4f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x2050
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x8f51
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/jid.c
// Function: xmpp_jid_domain
char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
{
    char *result = NULL;
    const char *c,*s;

    c = strchr(jid, '@');
    if (c == NULL) {
	/* no node, assume domain */
	c = jid;
    } else {
	/* advance past the separator */
	c++;
    }
    s = strchr(c, '/');
    if (s == NULL) {
	/* no resource */
	s = c + strlen(c);
    }
    result = xmpp_alloc(ctx, (s-c) + 1);
    if (result != NULL) {
	memcpy(result, c, (s-c));
	result[s-c] = '\0';
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f9b
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8fa7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2f, %esi
callq 0x21f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8fdf
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2180
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
addq $0x1, %rsi
callq 0x6680
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x902d
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x2050
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/jid.c
// Function: xmpp_jid_resource
char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid)
{
    char *result = NULL;
    const char *c;
    int len;

    c = strchr(jid, '/');
    if (c != NULL)  {
	c++;
	len = strlen(c);
	result = xmpp_alloc(ctx, len + 1);
	if (result != NULL) {
	    memcpy(result, c, len);
	    result[len] = '\0';
	}
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x90c5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2180
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x6680
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x90c3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x2050
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x90c5
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/md5.c
// Function: MD5Init
void MD5Init(struct MD5Context *ctx)
{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;

    ctx->bits[0] = 0;
    ctx->bits[1] = 0;

	memset(ctx->in, 0, 64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2140
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/md5.c
// Function: MD5Update
void MD5Update(struct MD5Context *ctx, unsigned char const *buf, uint32_t len)
{
    uint32_t t;

    /* Update bitcount */

    t = ctx->bits[0];
    if ((ctx->bits[0] = (t + ((uint32_t)len << 3)) & 0xffffffff) < t)
	ctx->bits[1]++;		/* Carry from low to high */
    ctx->bits[1] += len >> 29;

    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */

    /* Handle any leading odd-sized chunks */

    if (t) {
	unsigned char *p = ctx->in + t;

	t = 64 - t;
	if (len < t) {
	    memcpy(p, buf, len);
	    return;
	}
	memcpy(p, buf, t);
	MD5Transform(ctx->buf, ctx->in, ctx);
	buf += t;
	len -= t;
    }
    /* Process data in 64-byte chunks */

    while (len >= 64) {
	memcpy(ctx->in, buf, 64);
	MD5Transform(ctx->buf, ctx->in, ctx);
	buf += 64;
	len -= 64;
    }

    /* Handle any remaining bytes of data. */

    memcpy(ctx->in, buf, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
andl $-0x1, %eax
movq -0x8(%rbp), %rcx
movl %eax, 0x10(%rcx)
cmpl -0x18(%rbp), %eax
jae 0x9184
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x9224
movq -0x8(%rbp), %rax
addq $0x18, %rax
movl -0x18(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x40, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x91e2
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2050
jmp 0x9284
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rdx
callq 0x9290
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x9226
cmpl $0x40, -0x14(%rbp)
jb 0x926e
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rdx
callq 0x9290
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x40, %eax
movl %eax, -0x14(%rbp)
jmp 0x9226
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/parser_libxml2.c
// Function: parser_new
parser_t *parser_new(xmpp_ctx_t *ctx,
                     parser_start_callback startcb,
                     parser_end_callback endcb,
                     parser_stanza_callback stanzacb,
                     void *userdata)
{
    parser_t *parser;

    parser = xmpp_alloc(ctx, sizeof(parser_t));
    if (parser != NULL) {
        parser->ctx = ctx;
        parser->xmlctx = NULL;
        memset(&parser->handlers, 0, sizeof(xmlSAXHandler));
        parser->handlers.startElement = _start_element;
        parser->handlers.endElement = _end_element;
        parser->handlers.characters = _characters;
        parser->startcb = startcb;
        parser->endcb = endcb;
        parser->stanzacb = stanzacb;
        parser->userdata = userdata;
        parser->depth = 0;
        parser->stanza = NULL;

        parser_reset(parser);
    }

    return parser;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x140, %esi            # imm = 0x140
callq 0x6680
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa50c
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2140
movq -0x30(%rbp), %rax
leaq 0xa1(%rip), %rcx        # 0xa520
movq %rcx, 0x80(%rax)
movq -0x30(%rbp), %rax
leaq 0x20f(%rip), %rcx       # 0xa6a0
movq %rcx, 0x88(%rax)
movq -0x30(%rbp), %rax
leaq 0x2ed(%rip), %rcx       # 0xa790
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x130(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x30(%rbp), %rdi
callq 0xa810
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/parser_libxml2.c
// Function: end_element
static void _end_element(void *userdata, const xmlChar *name)
{
    parser_t *parser = (parser_t *)userdata;

    parser->depth--;

    if (parser->depth == 0) {
        /* notify owner */
        if (parser->endcb)
            parser->endcb((char *)name, parser->userdata);
    } else {
	if (parser->stanza->parent) {
	    /* we're finishing a child stanza, so set current to the parent */
	    parser->stanza = parser->stanza->parent;
	} else {
            if (parser->stanzacb)
                parser->stanzacb(parser->stanza,
                                 parser->userdata);
            xmpp_stanza_release(parser->stanza);
            parser->stanza = NULL;
	}
    }
}

// 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)
movq -0x18(%rbp), %rax
movl 0x130(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x130(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x130(%rax)
jne 0xa707
movq -0x18(%rbp), %rax
cmpq $0x0, 0x118(%rax)
je 0xa702
movq -0x18(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x128(%rcx), %rsi
callq *%rax
jmp 0xa787
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0xa735
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x138(%rax)
jmp 0xa785
movq -0x18(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0xa766
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x138(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x128(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rdi
callq 0x11f80
movq -0x18(%rbp), %rax
movq $0x0, 0x138(%rax)
jmp 0xa787
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/parser_libxml2.c
// Function: characters
static void _characters(void *userdata, const xmlChar *chr, int len)
{
    parser_t *parser = (parser_t *)userdata;
    xmpp_stanza_t *stanza;

    /* skip unimportant whitespace, etc */
    if (parser->depth < 2) return;

    /* create and populate stanza */
    stanza = xmpp_stanza_new(parser->ctx);
    if (!stanza) {
	/* FIXME: allocation error, disconnect */
	return;
    }
    xmpp_stanza_set_text_with_size(stanza, (char *)chr, len);

    xmpp_stanza_add_child(parser->stanza, stanza);
    xmpp_stanza_release(stanza);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x2, 0x130(%rax)
jge 0xa7ba
jmp 0xa801
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x11cb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa7d3
jmp 0xa801
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x12960
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x12850
movq -0x28(%rbp), %rdi
callq 0x11f80
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/parser_libxml2.c
// Function: parser_reset
int parser_reset(parser_t *parser)
{
    if (parser->xmlctx)
        xmlFreeParserCtxt(parser->xmlctx);

    if (parser->stanza) 
	xmpp_stanza_release(parser->stanza);

    parser->xmlctx = xmlCreatePushParserCtxt(&parser->handlers, 
                                             parser, NULL, 0, NULL);
    if (!parser->xmlctx) return 0;

    parser->depth = 0;
    parser->stanza = NULL;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa834
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2360
movq -0x10(%rbp), %rax
cmpq $0x0, 0x138(%rax)
je 0xa852
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rdi
callq 0x11f80
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rdx
callq 0x21b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa88c
movl $0x0, -0x4(%rbp)
jmp 0xa8b0
movq -0x10(%rbp), %rax
movl $0x0, 0x130(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x138(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/parser_libxml2.c
// Function: set_attributes
static void _set_attributes(xmpp_stanza_t *stanza, const xmlChar **attrs)
{
    int i;

    if (!attrs) return;

    for (i = 0; attrs[i]; i += 2) {
        xmpp_stanza_set_attribute(stanza, attrs[i], attrs[i+1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa969
jmp 0xa9b0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa9b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
callq 0x12760
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xa970
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sasl.c
// Function: sasl_plain
char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password) {
    int idlen, passlen;
    char *result = NULL;
    char *msg;
    
    /* our message is Base64(authzid,\0,authid,\0,password)
       if there is no authzid, that field is left empty */

    idlen = strlen(authid);
    passlen = strlen(password);
    msg = xmpp_alloc(ctx, 2 + idlen + passlen);
    if (msg != NULL) {
	msg[0] = '\0';
	memcpy(msg+1, authid, idlen);
	msg[1+idlen] = '\0';
	memcpy(msg+1+idlen+1, password, passlen);
	result = base64_encode(ctx, (unsigned char *)msg, 2 + idlen + passlen);
	xmpp_free(ctx, msg);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2180
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2180
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x2, %eax
addl -0x20(%rbp), %eax
movslq %eax, %rsi
callq 0x6680
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xaa88
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2050
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
addl $0x2, %edx
addl -0x20(%rbp), %edx
callq 0xaaa0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x66c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sasl.c
// Function: digest_to_hex
static void _digest_to_hex(const char *digest, char *hex)
{
    int i;
    const char hexdigit[] = "0123456789abcdef";

    for (i = 0; i < 16; i++) {
	*hex++ = hexdigit[ (digest[i] >> 4) & 0x0F ];
	*hex++ = hexdigit[ digest[i] & 0x0F ];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x95dd(%rip), %rax      # 0x14fd0
movq %rax, -0x30(%rbp)
movq 0x95da(%rip), %rax      # 0x14fd8
movq %rax, -0x28(%rbp)
movb 0x95d8(%rip), %al       # 0x14fe0
movb %al, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0xba72
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
sarl $0x4, %eax
andl $0xf, %eax
cltq
movb -0x30(%rbp,%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0xf, %eax
cltq
movb -0x30(%rbp,%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xba12
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sasl.c
// Function: base64_decoded_len
int base64_decoded_len(xmpp_ctx_t *ctx, 
		       const char * const buffer, const unsigned len)
{
    int nudge;
    int c;

    /* count the padding characters for the remainder */
    nudge = -1;
    c = _base64_invcharmap[(int)buffer[len-1]];
    if (c < 64) nudge = 0;
    else if (c == 64) {
	c = _base64_invcharmap[(int)buffer[len-2]];
	if (c < 64) nudge = 1;
	else if (c == 64) {
	    c = _base64_invcharmap[(int)buffer[len-3]];
	    if (c < 64) nudge = 2;
	} 
    }
    if (nudge < 0) return 0; /* reject bad coding */

    /* decoded steam is 3 bytes for every four */ 
    return 3 * (len >> 2) - nudge;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x9220(%rip), %rax      # 0x14ed0
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0xbcc6
movl $0x0, -0x20(%rbp)
jmp 0xbd38
cmpl $0x40, -0x24(%rbp)
jne 0xbd36
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x91ea(%rip), %rax      # 0x14ed0
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0xbcfc
movl $0x1, -0x20(%rbp)
jmp 0xbd34
cmpl $0x40, -0x24(%rbp)
jne 0xbd32
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x3, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x91b4(%rip), %rax      # 0x14ed0
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0xbd30
movl $0x2, -0x20(%rbp)
jmp 0xbd32
jmp 0xbd34
jmp 0xbd36
jmp 0xbd38
cmpl $0x0, -0x20(%rbp)
jge 0xbd47
movl $0x0, -0x4(%rbp)
jmp 0xbd56
movl -0x1c(%rbp), %eax
shrl $0x2, %eax
imull $0x3, %eax, %eax
subl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sasl.c
// Function: make_string
static char *_make_string(xmpp_ctx_t *ctx, const char *s, const unsigned len)
{
    char *result;

    result = xmpp_alloc(ctx, len + 1);
    if (result != NULL) {
	memcpy(result, s, len);
	result[len] = '\0';
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x6680
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc21e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x2050
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sasl.c
// Function: make_quoted
static char *_make_quoted(xmpp_ctx_t *ctx, const char *s)
{
    char *result;
    int len = strlen(s);

    result = xmpp_alloc(ctx, len + 3);
    if (result != NULL) {
	result[0] = '"';
	memcpy(result+1, s, len);
	result[len+1] = '"';
	result[len+2] = '\0';
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2180
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x3, %eax
movslq %eax, %rsi
callq 0x6680
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc2a7
movq -0x18(%rbp), %rax
movb $0x22, (%rax)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2050
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x22, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sha1.c
// Function: SHA1_Update
void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len)
{
    size_t i, j;

#ifdef VERBOSE
    SHAPrintContext(context, "before");
#endif

    j = (context->count[0] >> 3) & 63;
    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
    context->count[1] += (len >> 29);
    if ((j + len) > 63) {
        memcpy(&context->buffer[j], data, (i = 64-j));
        SHA1_Transform(context->state, context->buffer);
        for ( ; i + 63 < len; i += 64) {
            SHA1_Transform(context->state, data + i);
        }
        j = 0;
    }
    else i = 0;
    memcpy(&context->buffer[j], &data[i], len - i);

#ifdef VERBOSE
    SHAPrintContext(context, "after ");
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %eax
addq %rdx, %rax
movl %eax, 0x14(%rcx)
movl %eax, %eax
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
cmpq %rcx, %rax
jae 0xebc8
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rdx
shrq $0x1d, %rdx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addq %rdx, %rcx
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
cmpq $0x3f, %rax
jbe 0xec55
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
subq -0x28(%rbp), %rdx
movq %rdx, -0x20(%rbp)
callq 0x2050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1c, %rsi
callq 0xc2c0
movq -0x20(%rbp), %rax
addq $0x3f, %rax
cmpq -0x18(%rbp), %rax
jae 0xec4b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
callq 0xc2c0
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
jmp 0xec1e
movq $0x0, -0x28(%rbp)
jmp 0xec5d
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sha1.c
// Function: SHA1_Final
void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE])
{
    uint32_t i;
    uint8_t  finalcount[8];

    for (i = 0; i < 8; i++) {
        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
    }
    SHA1_Update(context, (uint8_t *)"\200", 1);
    while ((context->count[0] & 504) != 448) {
        SHA1_Update(context, (uint8_t *)"\0", 1);
    }
    SHA1_Update(context, finalcount, 8);  /* Should cause a SHA1_Transform() */
    for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
        digest[i] = (uint8_t)
         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
    }
    
    /* Wipe variables */
    i = 0;
    memset(context->buffer, 0, 64);
    memset(context->state, 0, 20);
    memset(context->count, 0, 8);
    memset(finalcount, 0, 8);	/* SWR */

#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite its own static vars */
    SHA1_Transform(context->state, context->buffer);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0xecf3
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x4, %esi
cmovael %edx, %ecx
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %eax
movl -0x14(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %cl
movl -0x14(%rbp), %eax
movb %cl, -0x1c(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xeca7
movq -0x8(%rbp), %rdi
leaq 0x62e3(%rip), %rsi      # 0x14fe1
movl $0x1, %edx
callq 0xeb70
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x1f8, %eax            # imm = 0x1F8
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0xed32
movq -0x8(%rbp), %rdi
leaq 0x62bd(%rip), %rsi      # 0x14fe3
movl $0x1, %edx
callq 0xeb70
jmp 0xed08
movq -0x8(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x8, %edx
callq 0xeb70
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jae 0xed8e
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xed4b
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2140
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x2140
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x2140
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/snprintf.c
// Function: fmtstr
static int fmtstr (char *buffer, size_t *currlen, size_t maxlen,
                   char *value, int flags, int min, int max)
{
  int padlen, strln;     /* amount to pad */
  int cnt = 0;
  int total = 0;
  
  if (value == 0)
  {
    value = "<NULL>";
  }

  for (strln = 0; value[strln]; ++strln); /* strlen */
  if (max >= 0 && max < strln)
    strln = max;
  padlen = min - strln;
  if (padlen < 0) 
    padlen = 0;
  if (flags & DP_F_MINUS) 
    padlen = -padlen; /* Left Justify */

  while (padlen > 0)
  {
    total += dopr_outch (buffer, currlen, maxlen, ' ');
    --padlen;
  }
  while (*value && ((max < 0) || (cnt < max)))
  {
    total += dopr_outch (buffer, currlen, maxlen, *value++);
    ++cnt;
  }
  while (padlen < 0)
  {
    total += dopr_outch (buffer, currlen, maxlen, ' ');
    ++padlen;
  }
  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10963
leaq 0x487b(%rip), %rax      # 0x151da
movq %rax, -0x20(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x10985
jmp 0x1097a
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1096a
cmpl $0x0, 0x10(%rbp)
jl 0x10999
movl 0x10(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x10999
movl 0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x109af
movl $0x0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x109c2
xorl %eax, %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x109c4
cmpl $0x0, -0x2c(%rbp)
jle 0x109f1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x20, %ecx
callq 0x100e0
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x109c4
jmp 0x109f3
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x10a21
movb $0x1, %al
cmpl $0x0, 0x10(%rbp)
movb %al, -0x3a(%rbp)
jl 0x10a1b
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
setl %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x10a2a
jmp 0x10a5e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %ecx
callq 0x100e0
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x109f3
jmp 0x10a60
cmpl $0x0, -0x2c(%rbp)
jge 0x10a8d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x20, %ecx
callq 0x100e0
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10a60
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/snprintf.c
// Function: abs_val
static LDOUBLE abs_val (LDOUBLE value)
{
  LDOUBLE result = value;

  if (value < 0)
    result = -value;

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x10ade
movsd -0x8(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/snprintf.c
// Function: snp_round
static long _snp_round (LDOUBLE value)
{
  long intpart;

  intpart = value;
  value = value - intpart;
  if (value >= 0.5)
    intpart++;

  return intpart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
cvttsd2si -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsi2sdq -0x10(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x467c(%rip), %xmm1     # 0x151a0
ucomisd %xmm1, %xmm0
jb 0x10b36
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/snprintf.c
// Function: snp_pow10
static LDOUBLE _snp_pow10 (int exp)
{
  LDOUBLE result = 1;

  while (exp)
  {
    result *= 10;
    exp--;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movsd 0x4659(%rip), %xmm0     # 0x151a8
movsd %xmm0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x10b77
movsd 0x464e(%rip), %xmm0     # 0x151b0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x10b54
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: sock_connect
sock_t sock_connect(const char * const host, const unsigned int port)
{
    sock_t sock;
    char service[6];
    struct addrinfo *res, *ainfo, hints;
    int err;
    
    sock = -1;

    snprintf(service, 6, "%u", port);

    memset(&hints, 0, sizeof(struct addrinfo));
    hints.ai_family = AF_INET;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_socktype = SOCK_STREAM;

    if ((err = getaddrinfo(host, service, &hints, &res)) != 0)
	return -1;

    ainfo = res;
    while (ainfo) {
	if ((sock = socket(ainfo->ai_family, ainfo->ai_socktype, 
		   ainfo->ai_protocol)) >= 0) {
	    sock_set_nonblocking(sock);

	    err = connect(sock, ainfo->ai_addr, ainfo->ai_addrlen);

	    if ((err == 0) || (err < 0 && _in_progress(sock_error())))
		break;
	}

	ainfo = ainfo->ai_next;
    }

    if (res) freeaddrinfo(res);

    return sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq -0x1e(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl $0x6, %esi
leaq 0x4608(%rip), %rdx      # 0x151e1
movb $0x0, %al
callq 0x21e0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2140
movl $0x2, -0x5c(%rbp)
movl $0x6, -0x54(%rbp)
movl $0x1, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x23d0
movl %eax, -0x64(%rbp)
cmpl $0x0, %eax
je 0x10c2e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10cc6
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x10cb0
movq -0x30(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x30(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x30(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x21a0
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jl 0x10ca2
movl -0x18(%rbp), %edi
callq 0x10cd0
movl -0x18(%rbp), %edi
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x30(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x2160
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x10c9e
cmpl $0x0, -0x64(%rbp)
jge 0x10ca0
callq 0x10ba0
movl %eax, %edi
callq 0x10d00
cmpl $0x0, %eax
je 0x10ca0
jmp 0x10cb0
jmp 0x10ca2
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x10c36
cmpq $0x0, -0x28(%rbp)
je 0x10cc0
movq -0x28(%rbp), %rdi
callq 0x2250
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: sock_connect_error
int sock_connect_error(const sock_t sock)
{
    struct sockaddr sa;
    unsigned len;
    char temp;

    sa.sa_family = AF_INET;

    len = sizeof(sa);

    /* we don't actually care about the peer name, we're just checking if
     * we're connected or not */
    if (getpeername(sock, &sa, &len) == 0)
    {
	return 0;
    }

    /* it's possible that the error wasn't ENOTCONN, so if it wasn't,
     * return that */
#ifdef _WIN32
    if (sock_error() != WSAENOTCONN) return sock_error();
#else
    if (sock_error() != ENOTCONN) return sock_error();
#endif

    /* load the correct error into errno through error slippage */
    recv(sock, &temp, 1, 0);

    return sock_error();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movw $0x2, -0x18(%rbp)
movl $0x10, -0x1c(%rbp)
movl -0x8(%rbp), %edi
leaq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x2440
cmpl $0x0, %eax
jne 0x10e46
movl $0x0, -0x4(%rbp)
jmp 0x10e75
callq 0x10ba0
cmpl $0x6b, %eax
je 0x10e5a
callq 0x10ba0
movl %eax, -0x4(%rbp)
jmp 0x10e75
movl -0x8(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2340
callq 0x10ba0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_add_32bitnum
void netbuf_add_32bitnum(unsigned char *buf, int buflen, int *offset, unsigned int num)
{
	unsigned char *start = buf + *offset;
	unsigned char *p = start;

	/* assuming big endian */
	*p++ = (num >> 24) & 0xff;
	*p++ = (num >> 16) & 0xff;
	*p++ = (num >> 8)  & 0xff;
	*p++ = (num)       & 0xff;

	*offset += 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_get_32bitnum
void netbuf_get_32bitnum(unsigned char *buf, int buflen, int *offset, unsigned int *num)
{
	unsigned char *start = buf + *offset;
	unsigned char *p = start;
	*num = 0;

	/* assuming big endian */
	*num |= (*p++) << 24;
	*num |= (*p++) << 16;
	*num |= (*p++) << 8;
	*num |= (*p++);

	*offset += 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %ecx
shll $0x10, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x4, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_add_16bitnum
void netbuf_add_16bitnum(unsigned char *buf, int buflen, int *offset, unsigned short num)
{
	unsigned char *start = buf + *offset;
	unsigned char *p = start;

	/* assuming big endian */
	*p++ = (num >> 8) & 0xff;
	*p++ = (num)      & 0xff;

	*offset += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movzwl -0x1a(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movzwl -0x1a(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_get_16bitnum
void netbuf_get_16bitnum(unsigned char *buf, int buflen, int *offset, unsigned short *num)
{
	unsigned char *start = buf + *offset;
	unsigned char *p = start;
	*num = 0;

	/* assuming big endian */
	*num |= (*p++) << 8;
	*num |= (*p++);

	*offset += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movw $0x0, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %edx
shll $0x8, %edx
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
orl %edx, %ecx
movw %cx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movzbl (%rax), %edx
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
orl %edx, %ecx
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_add_domain_name
void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset, 
			    char *name)
{
	unsigned char *start = buf + *offset;
	unsigned char *p = start;
	unsigned char *wordstart, *wordend;

	wordstart = (unsigned char *)name;
	
	while (*wordstart)
	{
		int len;
		wordend = wordstart;
		while (*wordend && *wordend != '.')
		{
			wordend++;
		}

		len = (int)(wordend - wordstart);

		if (len > 0x3F)
		{
			len = 0x3F;
		}

		*p++ = len;

		while (wordstart != wordend)
		{
			*p++ = *wordstart++;
		}

		if (*wordstart == '.')
		{
			wordstart++;
		}
	}

	*p++ = '\0';

	*offset += p - start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x111fe
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x45(%rbp)
je 0x1116b
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x11174
jmp 0x11182
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x1114a
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
cmpl $0x3f, -0x44(%rbp)
jle 0x1119d
movl $0x3f, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x111e1
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x111b3
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x111f9
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x11135
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
movb $0x0, (%rax)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: calc_domain_name_size
int calc_domain_name_size(unsigned char *buf, int buflen, int offset)
{
	unsigned char *p = buf + offset;
	int len = 0;

	while (*p)
	{
		if ((*p & 0xC0) == 0xC0)
		{
			int newoffset = 0;
			newoffset |= (*p++ & 0x3F) << 8;
			newoffset |= *p;

			p = buf + newoffset;
		}
		else
		{
			if (len)
			{
				len += 1;
			}
			len += *p;
			p += *p + 1;
		}
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x112f0
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x112b7
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
andl $0x3f, %eax
shll $0x8, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x112eb
cmpl $0x0, -0x1c(%rbp)
je 0x112c6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x11254
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/src/sock.c
// Function: netbuf_add_dnsquery_header
void netbuf_add_dnsquery_header(unsigned char *buf, int buflen, int *offset, struct dnsquery_header *header)
{
	unsigned char *p;

	netbuf_add_16bitnum(buf, buflen, offset, header->id);
	
	p = buf + *offset;
	*p++ =    ((header->qr     & 0x01) << 7)
		| ((header->opcode & 0x0F) << 3)
		| ((header->aa     & 0x01) << 2)
		| ((header->tc     & 0x01) << 1)
		| ((header->rd     & 0x01));
	*p++ =    ((header->ra     & 0x01) << 7)
		| ((header->z      & 0x07) << 4)
		| ((header->rcode  & 0x0F));
	*offset += 2;

	netbuf_add_16bitnum(buf, buflen, offset, header->qdcount);
	netbuf_add_16bitnum(buf, buflen, offset, header->ancount);
	netbuf_add_16bitnum(buf, buflen, offset, header->nscount);
	netbuf_add_16bitnum(buf, buflen, offset, header->arcount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
callq 0x10ff0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x1, %eax
shll $0x7, %eax
movq -0x20(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
andl $0xf, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
andl $0x1, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
andl $0x1, %ecx
shll %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
andl $0x1, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movzbl 0x7(%rax), %eax
andl $0x1, %eax
shll $0x7, %eax
movq -0x20(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
andl $0x7, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x20(%rbp), %rcx
movzbl 0x9(%rcx), %ecx
andl $0xf, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzwl 0xa(%rax), %ecx
callq 0x10ff0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzwl 0xc(%rax), %ecx
callq 0x10ff0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %ecx
callq 0x10ff0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movzwl 0x10(%rax), %ecx
callq 0x10ff0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)