// File: /workspace/github_c_makefile_star2_O3/wtarreau[P]httpterm/httpterm.c
// Function: readcfgfile
int readcfgfile(char *file) {
    char thisline[256];
    char *line;
    FILE *f = NULL;
    int linenum = 0;
    char *end;
    char *args[MAX_LINE_ARGS];
    int arg;
    int cfgerr = 0;
    int confsect = CFG_NONE;

    struct proxy *curproxy = NULL;
    struct server *newsrv = NULL;

    if (file && (f=fopen(file,"r")) == NULL)
	return -1;

    init_default_instance();

    while (f && fgets(line = thisline, sizeof(thisline), f) != NULL) {
	linenum++;

	end = line + strlen(line);

	/* skip leading spaces */
	while (isspace((int)*line))
	    line++;
	
	arg = 0;
	args[arg] = line;

	while (*line && arg < MAX_LINE_ARGS) {
	    /* first, we'll replace \\, \<space>, \#, \r, \n, \t, \xXX with their
	     * C equivalent value. Other combinations left unchanged (eg: \1).
	     */
	    if (*line == '\\') {
		int skip = 0;
		if (line[1] == ' ' || line[1] == '\\' || line[1] == '#') {
		    *line = line[1];
		    skip = 1;
		}
		else if (line[1] == 'r') {
		    *line = '\r';
		    skip = 1;
		} 
		else if (line[1] == 'n') {
		    *line = '\n';
		    skip = 1;
		}
		else if (line[1] == 't') {
		    *line = '\t';
		    skip = 1;
		}
		else if (line[1] == 'x') {
		    if ((line + 3 < end ) && ishex(line[2]) && ishex(line[3])) {
			unsigned char hex1, hex2;
			hex1 = toupper(line[2]) - '0';
			hex2 = toupper(line[3]) - '0';
			if (hex1 > 9) hex1 -= 'A' - '9' - 1;
			if (hex2 > 9) hex2 -= 'A' - '9' - 1;
			*line = (hex1<<4) + hex2;
			skip = 3;
		    }
		    else {
			Alert("parsing [%s:%d] : invalid or incomplete '\\x' sequence in '%s'.\n", file, linenum, args[0]);
			return -1;
		    }
		}
		if (skip) {
		    memmove(line + 1, line + 1 + skip, end - (line + skip + 1));
		    end -= skip;
		}
		line++;
	    }
	    else if (*line == '#' || *line == '\n' || *line == '\r') {
		/* end of string, end of loop */
		*line = 0;
		break;
	    }
	    else if (isspace((int)*line)) {
		/* a non-escaped space is an argument separator */
		*line++ = 0;
		while (isspace((int)*line))
		    line++;
		args[++arg] = line;
	    }
	    else {
		line++;
	    }
	}

	/* empty line */
	if (!**args)
	    continue;

	/* zero out remaining args */
	while (++arg < MAX_LINE_ARGS) {
	    args[arg] = line;
	}

	if (!strcmp(args[0], "listen") || !strcmp(args[0], "defaults"))  /* new proxy */
	    confsect = CFG_LISTEN;
	else if (!strcmp(args[0], "global"))  /* global config */
	    confsect = CFG_GLOBAL;
	/* else it's a section keyword */

	switch (confsect) {
	case CFG_LISTEN:
	    if (cfg_parse_listen(file, linenum, args) < 0)
		return -1;
	    break;
	case CFG_GLOBAL:
	    if (cfg_parse_global(file, linenum, args) < 0)
		return -1;
	    break;
	default:
	    Alert("parsing [%s:%d] : unknown keyword '%s' out of section.\n", file, linenum, args[0]);
	    return -1;
	}
	    
	    
    }
    if (f)
	fclose(f);

    /* Maybe the user has specified a listener on the command line */
    if (cmdline_listen) {
	const char *name = "command line";
	args[0] = "listen";
	args[1] = "dummy";
	args[2] = "\0";
	if (cfg_parse_listen(name, 0, args) < 0)
	    return -1;

	args[0] = "bind";
	args[1] = cmdline_listen;
	args[2] = "\0";
	if (cfg_parse_listen(name, 0, args) < 0)
	    return -1;

	args[0] = "object";
	args[1] = "name";
	args[2] = "dummy";
	args[3] = "\0";
	if (cfg_parse_listen(name, 0, args) < 0)
	    return -1;

	args[0] = "clitimeout";
	args[1] = "10000";
	args[2] = "\0";
	if (cfg_parse_listen(name, 0, args) < 0)
	    return -1;
    }

    /*
     * Now, check for the integrity of all that we have collected.
     */

    /* will be needed further to delay some tasks */
    tv_now(&now);

    if ((curproxy = proxy) == NULL) {
	Alert("parsing %s : no <listen> line. Nothing to do !\n",
	      file);
	return -1;
    }

    while (curproxy != NULL) {
	if (curproxy->state == PR_STSTOPPED) {
	    curproxy = curproxy->next;
	    continue;
	}

	if (curproxy->listen == NULL) {
	    Alert("parsing %s : listener %s has no listen address. Please either specify a valid address on the <listen> line, or use the <bind> keyword.\n", file, curproxy->id);
	    cfgerr++;
	}

	/* first, we will invert the servers list order */
	newsrv = NULL;
	while (curproxy->srv) {
	    struct server *next;

	    next = curproxy->srv->next;
	    curproxy->srv->next = newsrv;
	    newsrv = curproxy->srv;
	    if (!next)
		break;
	    curproxy->srv = next;
	}

	/* now, newsrv == curproxy->srv */
	if (newsrv) {
	    struct server *srv;
	    int pgcd;
	    int act;

	    /* We will factor the weights to reduce the table,
	     * using Euclide's largest common divisor algorithm
	     */
	    pgcd = newsrv->uweight + 1;
	    for (srv = newsrv->next; srv && pgcd > 1; srv = srv->next) {
		int t, w;
		
		w = srv->uweight + 1;
		while (w) {
		    t = pgcd % w;
		    pgcd = w;
		    w = t;
		}
	    }

	    act = 0;
	    for (srv = newsrv; srv; srv = srv->next) {
		srv->eweight = ((srv->uweight + 1) / pgcd) - 1;
		act += srv->eweight + 1;
	    }

	    curproxy->srv_map = (struct server **)calloc(act, sizeof(struct server *));
	    /* recounts servers and their weights */
	    recount_servers(curproxy);
	    recalc_server_map(curproxy);
	}

	if (curproxy->errmsg.msg400 == NULL) {
	    curproxy->errmsg.msg400 = (char *)HTTP_400;
	    curproxy->errmsg.len400 = strlen(HTTP_400);
	}
	if (curproxy->errmsg.msg403 == NULL) {
	    curproxy->errmsg.msg403 = (char *)HTTP_403;
	    curproxy->errmsg.len403 = strlen(HTTP_403);
	}
	if (curproxy->errmsg.msg408 == NULL) {
	    curproxy->errmsg.msg408 = (char *)HTTP_408;
	    curproxy->errmsg.len408 = strlen(HTTP_408);
	}
	if (curproxy->errmsg.msg500 == NULL) {
	    curproxy->errmsg.msg500 = (char *)HTTP_500;
	    curproxy->errmsg.len500 = strlen(HTTP_500);
	}
	if (curproxy->errmsg.msg502 == NULL) {
	    curproxy->errmsg.msg502 = (char *)HTTP_502;
	    curproxy->errmsg.len502 = strlen(HTTP_502);
	}
	if (curproxy->errmsg.msg503 == NULL) {
	    curproxy->errmsg.msg503 = (char *)HTTP_503;
	    curproxy->errmsg.len503 = strlen(HTTP_503);
	}
	if (curproxy->errmsg.msg504 == NULL) {
	    curproxy->errmsg.msg504 = (char *)HTTP_504;
	    curproxy->errmsg.len504 = strlen(HTTP_504);
	}
	curproxy = curproxy->next;
    }
    if (cfgerr > 0) {
	Alert("Errors found in configuration file, aborting.\n");
	return -1;
    }
    else
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %r12
testq %rdi, %rdi
je 0x72ee
leaq 0x38c0(%rip), %rsi      # 0xab99
movq %r12, %rdi
callq 0x2340
movq %rax, %r15
testq %rax, %rax
jne 0x72f1
jmp 0x7abd
xorl %r15d, %r15d
leaq 0x27158(%rip), %rdi     # 0x2e450
movl $0xe0, %edx
xorl %esi, %esi
callq 0x21a0
movl 0x6026(%rip), %eax      # 0xd330
testl %eax, %eax
jne 0x7314
movl 0x6094(%rip), %eax      # 0xd3a8
testl %eax, %eax
movl $0x40000000, %ecx       # imm = 0x40000000
cmovnel %eax, %ecx
movl %ecx, 0x27174(%rip)     # 0x2e498
testq %r15, %r15
je 0x76f0
movq %r12, 0x8(%rsp)
leaq 0x170(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdx
callq 0x21e0
testq %rax, %rax
je 0x76e3
callq 0x2420
movq %rax, %rbp
movq $0x0, 0x18(%rsp)
leaq 0x170(%rsp), %rbx
xorl %r14d, %r14d
movq %r15, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2130
movq (%rbp), %rdx
leaq 0x16f(%rsp), %r13
movsbq 0x1(%r13), %rcx
incq %r13
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x7385
incl %r14d
movq %r13, 0x30(%rsp)
testb %cl, %cl
je 0x754f
movl %r14d, 0x14(%rsp)
leaq (%rsp,%rax), %r14
addq $0x170, %r14            # imm = 0x170
xorl %r12d, %r12d
cmpb $0x5c, %cl
je 0x73ee
movzbl %cl, %eax
cmpl $0x23, %eax
ja 0x73da
movl %eax, %eax
movabsq $0x800002400, %rdx      # imm = 0x800002400
btq %rax, %rdx
jb 0x7561
movq (%rbp), %rax
movsbq %cl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x7424
incq %r13
jmp 0x7447
movq %rbp, %r15
leaq 0x1(%r13), %rbx
movb 0x1(%r13), %al
movzbl %al, %ecx
movl $0x1, %ebp
cmpl $0x6d, %ecx
jle 0x744f
cmpl $0x73, %ecx
jg 0x7474
cmpl $0x6e, %ecx
je 0x7512
cmpl $0x72, %ecx
jne 0x7537
movb $0xd, %al
jmp 0x7518
movb $0x0, (%r13)
movq (%rbp), %rax
movsbq 0x1(%r13), %rcx
incq %r13
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x742d
movslq %r12d, %rax
incl %r12d
movq %r13, 0x38(%rsp,%rax,8)
movq %r13, %rbx
jmp 0x753a
addl $-0x20, %ecx
cmpl $0x3c, %ecx
ja 0x7537
movabsq $0x1000000000000009, %rdx # imm = 0x1000000000000009
btq %rcx, %rdx
jb 0x7518
jmp 0x7537
cmpl $0x74, %ecx
je 0x7516
cmpl $0x78, %ecx
jne 0x7537
leaq 0x3(%r13), %rax
cmpq %r14, %rax
jae 0x7a8e
movsbq 0x2(%r13), %rdx
leal -0x3a(%rdx), %ecx
cmpb $-0xb, %cl
ja 0x74b1
movl %edx, %ecx
andb $-0x21, %cl
addb $-0x47, %cl
cmpb $-0x6, %cl
jb 0x7a8e
movsbq (%rax), %rbp
leal -0x3a(%rbp), %eax
cmpb $-0xb, %al
ja 0x74ca
movl %ebp, %eax
andb $-0x21, %al
addb $-0x47, %al
cmpb $-0x6, %al
jb 0x7a8e
movq %rdx, 0x28(%rsp)
callq 0x2030
movq (%rax), %rax
movq 0x28(%rsp), %rcx
movb (%rax,%rcx,4), %cl
movb (%rax,%rbp,4), %al
leal -0x30(%rax), %edx
leal -0x3a(%rcx), %esi
addb $-0x37, %al
cmpb $0xa, %dl
movzbl %al, %eax
movzbl %dl, %edx
cmovael %eax, %edx
shlb $0x4, %cl
leal -0x70(%rcx), %eax
cmpb $-0xa, %sil
movzbl %cl, %ecx
movzbl %al, %eax
cmovael %ecx, %eax
addb %dl, %al
movl $0x3, %ebp
jmp 0x7518
movb $0xa, %al
jmp 0x7518
movb $0x9, %al
movb %al, (%r13)
leaq (%rbx,%rbp), %rsi
addq %rbp, %r13
notq %r13
addq %r14, %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2300
subq %rbp, %r14
movq %r15, %rbp
movb (%rbx), %cl
testb %cl, %cl
je 0x7569
movq %rbx, %r13
cmpl $0x28, %r12d
jl 0x73b7
jmp 0x7569
movq 0x30(%rsp), %rax
cmpb $0x0, (%rax)
je 0x757a
xorl %r12d, %r12d
movq %r13, %rbx
jmp 0x75af
movb $0x0, (%r13)
movq %r13, %rbx
movq 0x30(%rsp), %r13
cmpb $0x0, (%r13)
movl 0x14(%rsp), %r14d
jne 0x75a5
leaq 0x170(%rsp), %rbx
movq %rbx, %rdi
movl $0x100, %esi            # imm = 0x100
movq 0x20(%rsp), %r15
movq %r15, %rdx
callq 0x21e0
testq %rax, %rax
jne 0x7371
jmp 0x76e3
cmpl $0x26, %r12d
jg 0x7655
movslq %r12d, %rcx
movl $0x28, %eax
subq %rcx, %rax
andq $-0x2, %rax
movl $0x26, %edx
subq %rcx, %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x40(%rsp), %rdx
leaq (%rdx,%rcx,8), %rcx
movdqa 0x1a4f(%rip), %xmm5     # 0x9030
pxor %xmm5, %xmm0
xorl %edx, %edx
movdqa 0x1a31(%rip), %xmm4     # 0x9020
pcmpeqd %xmm6, %xmm6
movq %rdx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
por %xmm4, %xmm1
pxor %xmm5, %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
pshufd $0xf5, %xmm1, %xmm3     # xmm3 = xmm1[1,1,3,3]
pand %xmm2, %xmm3
pshufd $0xf5, %xmm2, %xmm1     # xmm1 = xmm2[1,1,3,3]
por %xmm3, %xmm1
movd %xmm1, %esi
notl %esi
testb $0x1, %sil
je 0x7634
movq %rbx, -0x8(%rcx,%rdx,8)
pxor %xmm6, %xmm1
pextrw $0x4, %xmm1, %esi
testb $0x1, %sil
je 0x7647
movq %rbx, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x75f3
movq 0x30(%rsp), %r13
movq %r13, %rdi
leaq 0x300c(%rip), %rsi      # 0xa66b
callq 0x2200
testl %eax, %eax
je 0x76a1
movq %r13, %rdi
leaq 0x309a(%rip), %rsi      # 0xa70c
callq 0x2200
testl %eax, %eax
je 0x76a1
movq %r13, %rdi
leaq 0x2e57(%rip), %rsi      # 0xa4dc
callq 0x2200
testl %eax, %eax
movq 0x18(%rsp), %rax
je 0x76ba
cmpl $0x1, %eax
je 0x76ba
cmpl $0x2, %eax
jne 0x7ada
movq 0x8(%rsp), %rdi
movl %r14d, %esi
leaq 0x30(%rsp), %rdx
callq 0x6836
movl $0x2, %ecx
jmp 0x76d1
movq 0x8(%rsp), %rdi
movl %r14d, %esi
leaq 0x30(%rsp), %rdx
callq 0x6475
movl $0x1, %ecx
testl %eax, %eax
js 0x7abd
movq %rcx, 0x18(%rsp)
jmp 0x757a
movq %r15, %rdi
callq 0x2110
movq 0x8(%rsp), %r12
cmpq $0x0, 0x5c50(%rip)      # 0xd348
je 0x77de
leaq 0x2f66(%rip), %rax      # 0xa66b
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x350c(%rip), %r15      # 0xac20
movq %r15, 0x8(%rdx)
leaq 0x1aa1(%rip), %r14      # 0x91c0
movq %r14, 0x10(%rdx)
leaq 0x34e9(%rip), %rdi      # 0xac13
xorl %esi, %esi
callq 0x6836
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x7ac2
leaq 0x3004(%rip), %rax      # 0xa749
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movq 0x5bf4(%rip), %rax      # 0xd348
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
leaq 0x34b0(%rip), %rdi      # 0xac13
xorl %esi, %esi
callq 0x6836
testl %eax, %eax
js 0x7ac2
leaq 0x3186(%rip), %rax      # 0xa8ff
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x31b3(%rip), %rax      # 0xa93b
movq %rax, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq %r14, 0x18(%rdx)
leaq 0x3478(%rip), %rdi      # 0xac13
xorl %esi, %esi
callq 0x6836
testl %eax, %eax
js 0x7ac2
leaq 0x3043(%rip), %rax      # 0xa7f4
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3466(%rip), %rax      # 0xac26
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
leaq 0x3444(%rip), %rdi      # 0xac13
xorl %esi, %esi
callq 0x6836
testl %eax, %eax
js 0x7ac2
leaq 0x5c1b(%rip), %rdi      # 0xd400
xorl %esi, %esi
callq 0x2190
movq 0x5b85(%rip), %rbx      # 0xd378
testq %rbx, %rbx
je 0x7aac
leaq 0x3459(%rip), %r14      # 0xac5c
xorl %ebp, %ebp
cmpl $0x3, 0x8(%rbx)
jne 0x7819
movq 0x50(%rbx), %rbx
testq %rbx, %rbx
jne 0x7805
jmp 0x7a7a
cmpq $0x0, (%rbx)
jne 0x7832
movq 0x38(%rbx), %rdx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x29fa
incl %ebp
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x7985
movq (%rcx), %rax
movq $0x0, (%rcx)
testq %rax, %rax
je 0x7865
movq %rcx, %rdi
movq %rax, %rcx
movq (%rax), %rax
movq %rdi, (%rcx)
testq %rax, %rax
jne 0x784e
movq %rcx, 0x10(%rbx)
jmp 0x7867
xorl %edi, %edi
movb 0x10(%rcx), %al
movzbl %al, %eax
leal 0x1(%rax), %esi
testq %rdi, %rdi
setne %dl
testb %al, %al
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0x78a0
movzbl 0x10(%rdi), %edx
incl %edx
movl %esi, %eax
movl %edx, %esi
xorl %edx, %edx
divl %esi
testl %edx, %edx
jne 0x7887
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x78a0
cmpl $0x1, %esi
jg 0x7881
xorl %edi, %edi
movzbl 0x10(%rcx), %eax
incl %eax
xorl %edx, %edx
divl %esi
decb %al
movb %al, 0x11(%rcx)
movzbl %al, %eax
addl %eax, %edi
incl %edi
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x78a2
movl %edi, %edi
movl $0x8, %esi
callq 0x21f0
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq 0x10(%rbx), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x7982
xorl %edx, %edx
movq %rax, %rsi
incl %edx
movzbl 0x11(%rsi), %edi
addl %edi, %ecx
incl %ecx
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x78ec
movl %edx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
movl $0x0, 0x14(%rax)
movq (%rax), %rax
testq %rax, %rax
jne 0x7904
testl %ecx, %ecx
jle 0x7982
movl %ecx, %esi
xorl %edi, %edi
movq 0x10(%rbx), %r8
cmpl $0x1, %ecx
jne 0x7929
movq %r8, %r9
jmp 0x796e
xorl %r10d, %r10d
xorl %r9d, %r9d
movzbl 0x11(%r8), %eax
movl 0x14(%r8), %edx
leal (%rax,%rdx), %r11d
addl %edx, %eax
incl %eax
movl %eax, 0x14(%r8)
leal (%rcx,%r11), %eax
incl %eax
xorl %edx, %edx
divl %ecx
testq %r9, %r9
sete %dl
cmpl %r10d, %eax
setg %r11b
orb %dl, %r11b
cmovneq %r8, %r9
cmovnel %eax, %r10d
movq (%r8), %r8
testq %r8, %r8
jne 0x792f
movq 0x20(%rbx), %rax
movq %r9, (%rax,%rdi,8)
subl %ecx, 0x14(%r9)
incq %rdi
cmpq %rsi, %rdi
jne 0x791b
movl %ecx, 0x28(%rbx)
cmpq $0x0, 0x70(%rbx)
jne 0x799f
movq 0x594d(%rip), %rdi      # 0xd2e0
movq %rdi, 0x70(%rbx)
callq 0x2130
movl %eax, 0x78(%rbx)
cmpq $0x0, 0x80(%rbx)
jne 0x79c2
movq 0x5938(%rip), %rdi      # 0xd2e8
movq %rdi, 0x80(%rbx)
callq 0x2130
movl %eax, 0x88(%rbx)
cmpq $0x0, 0x90(%rbx)
jne 0x79e5
movq 0x591d(%rip), %rdi      # 0xd2f0
movq %rdi, 0x90(%rbx)
callq 0x2130
movl %eax, 0x98(%rbx)
cmpq $0x0, 0xa0(%rbx)
jne 0x7a08
movq 0x5902(%rip), %rdi      # 0xd2f8
movq %rdi, 0xa0(%rbx)
callq 0x2130
movl %eax, 0xa8(%rbx)
cmpq $0x0, 0xb0(%rbx)
jne 0x7a2b
movq 0x58e7(%rip), %rdi      # 0xd300
movq %rdi, 0xb0(%rbx)
callq 0x2130
movl %eax, 0xb8(%rbx)
cmpq $0x0, 0xc0(%rbx)
jne 0x7a4e
movq 0x58cc(%rip), %rdi      # 0xd308
movq %rdi, 0xc0(%rbx)
callq 0x2130
movl %eax, 0xc8(%rbx)
cmpq $0x0, 0xd0(%rbx)
jne 0x780b
movq 0x58ad(%rip), %rdi      # 0xd310
movq %rdi, 0xd0(%rbx)
callq 0x2130
movl %eax, 0xd8(%rbx)
jmp 0x780b
testl %ebp, %ebp
jle 0x7ad6
leaq 0x325f(%rip), %rdi      # 0xace4
xorl %eax, %eax
callq 0x29fa
jmp 0x7abd
movq 0x30(%rsp), %rcx
leaq 0x3101(%rip), %rdi      # 0xab9b
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %edx
xorl %eax, %eax
callq 0x29fa
jmp 0x7abd
leaq 0x3179(%rip), %rdi      # 0xac2c
movq %r12, %rsi
xorl %eax, %eax
callq 0x29fa
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x7ac2
leaq 0x30fa(%rip), %rdi      # 0xabdb
movq 0x8(%rsp), %rsi
movl %r14d, %edx
movq %r13, %rcx
jmp 0x7aa3