#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ keylen;

/* Variables and functions */
int /*<<< orphan*/ free(char *);
scalar_t__ isalnum(char);
scalar_t__ isspace(char);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int get_key_value(char *buf, char **ppkey, char **ppval) {
  char *saveptr, *key, *value, *line;
  int keylen, vallen;
  line = buf;
  *ppkey = *ppval = NULL;
  if (line == NULL) {
    printf("buf is null\n");
    return -1;
  }
  for (; *line && isspace(*line); line++)
    ;
  if (*line == 0 || *line == '#') {
    return 0;
  }
  if (*line == '[') {
    key = ++line;
    while (*line && *line != ']')
      line++;
    if (*line == ']')
      *line = 0;
    else {
      printf("invalid line, line[%s]\n", buf);
      return -1;
    }
    keylen = strlen(key);
    *ppkey = (char *)malloc(sizeof(keylen) + 1);
    if (*ppkey == NULL) {
      printf("malloc key failed.\n");
      return -1;
    }
    strcpy(*ppkey, key);
    return 0;
  }
  key = line;
  while (*line && isalnum(*line))
    line++;
  if (*line == 0) {
    printf("invalid line[%s]\n", buf);
    return -1;
  }
  keylen = line - key;
  while (*line && isspace(*line))
    line++;
  if (*line++ != '=') {
    printf("invalid line[%s]\n", buf);
    return -1;
  }
  while (*line && isspace(*line))
    line++;
  if (!isalnum(*line) || *line == '#') {
    printf("invalid line[%s]\n", buf);
    return -1;
  }
  value = line;
  while (*line && isalnum(*line) && *line != '#')
    line++;
  vallen = line - value;
  while (*line && isspace(*line))
    line++;
  if (*line != 0 && *line != '#') {
    printf("invalid line[%s]\n", buf);
    return -1;
  }
  *ppkey = (char *)malloc(keylen + 1);
  if (*ppkey == NULL) {
    printf("malloc ppkey failed.\n");
    return -1;
  }
  *ppval = (char *)malloc(vallen + 1);
  if (*ppval == NULL) {
    free(*ppkey);
    *ppkey = NULL;
    printf("malloc ppval failed.\n");
    return -1;
  }
  memcpy(*ppkey, key, keylen);
  memcpy(*ppval, value, vallen);
  *(*ppkey + keylen) = 0;
  *(*ppval + vallen) = 0;
  return 0;
}


x86 assembly (clang, -O0):
<get_key_value>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
cmpq   $0x0,-0x40(%rbp)
jne    11d7 <get_key_value+0x57>
lea    0xe3c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
jmp    11dc <get_key_value+0x5c>
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x49(%rbp)
je     1207 <get_key_value+0x87>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1217 <get_key_value+0x97>
jmp    122d <get_key_value+0xad>
jmp    121c <get_key_value+0x9c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11dc <get_key_value+0x5c>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     124d <get_key_value+0xcd>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
jne    1259 <get_key_value+0xd9>
movl   $0x0,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5b,%eax
jne    135d <get_key_value+0x1dd>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4a(%rbp)
je     129e <get_key_value+0x11e>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5d,%eax
setne  %al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
test   $0x1,%al
jne    12ae <get_key_value+0x12e>
jmp    12bf <get_key_value+0x13f>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1279 <get_key_value+0xf9>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5d,%eax
jne    12db <get_key_value+0x15b>
mov    -0x40(%rbp),%rax
movb   $0x0,(%rax)
jmp    12f9 <get_key_value+0x179>
mov    -0x10(%rbp),%rsi
lea    0xd27(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x30(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x44(%rbp)
mov    $0x5,%edi
call   10a0 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1341 <get_key_value+0x1c1>
lea    0xcf7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x30(%rbp),%rsi
call   1040 <strcpy@plt>
movl   $0x0,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4b(%rbp)
je     1390 <get_key_value+0x210>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isalnum@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4b(%rbp)
mov    -0x4b(%rbp),%al
test   $0x1,%al
jne    13a0 <get_key_value+0x220>
jmp    13b1 <get_key_value+0x231>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1365 <get_key_value+0x1e5>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    13df <get_key_value+0x25f>
mov    -0x10(%rbp),%rsi
lea    0xc6d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4c(%rbp)
je     1418 <get_key_value+0x298>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4c(%rbp)
mov    -0x4c(%rbp),%al
test   $0x1,%al
jne    1428 <get_key_value+0x2a8>
jmp    1439 <get_key_value+0x2b9>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13ed <get_key_value+0x26d>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movsbl (%rax),%eax
cmp    $0x3d,%eax
je     1472 <get_key_value+0x2f2>
mov    -0x10(%rbp),%rsi
lea    0xbda(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
jmp    1477 <get_key_value+0x2f7>
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4d(%rbp)
je     14a2 <get_key_value+0x322>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    14b2 <get_key_value+0x332>
jmp    14c3 <get_key_value+0x343>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1477 <get_key_value+0x2f7>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isalnum@plt>
cmp    $0x0,%rax
je     14e9 <get_key_value+0x369>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
jne    1507 <get_key_value+0x387>
mov    -0x10(%rbp),%rsi
lea    0xb45(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4e(%rbp)
je     1552 <get_key_value+0x3d2>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isalnum@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x4e(%rbp)
je     1552 <get_key_value+0x3d2>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
setne  %al
mov    %al,-0x4e(%rbp)
mov    -0x4e(%rbp),%al
test   $0x1,%al
jne    1562 <get_key_value+0x3e2>
jmp    1573 <get_key_value+0x3f3>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    150f <get_key_value+0x38f>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x4f(%rbp)
je     15ac <get_key_value+0x42c>
mov    -0x40(%rbp),%rax
movsbl (%rax),%edi
call   1080 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x4f(%rbp)
mov    -0x4f(%rbp),%al
test   $0x1,%al
jne    15bc <get_key_value+0x43c>
jmp    15cd <get_key_value+0x44d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1581 <get_key_value+0x401>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     160b <get_key_value+0x48b>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x23,%eax
je     160b <get_key_value+0x48b>
mov    -0x10(%rbp),%rsi
lea    0xa41(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x44(%rbp),%edi
add    $0x1,%edi
call   10a0 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1648 <get_key_value+0x4c8>
lea    0xa16(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x48(%rbp),%edi
add    $0x1,%edi
call   10a0 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
cmpq   $0x0,(%rax)
jne    169c <get_key_value+0x51c>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
lea    0x9d8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    16e7 <get_key_value+0x567>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x44(%rbp),%edx
call   1090 <memcpy@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%edx
call   1090 <memcpy@plt>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x44(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x48(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_key_value>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
movq   $0x0,(%rdx)
movq   $0x0,(%rsi)
test   %rdi,%rdi
je     11f3 <get_key_value+0x63>
mov    %rdi,%r13
mov    (%rdi),%al
xor    %r12d,%r12d
test   %al,%al
je     1205 <get_key_value+0x75>
mov    %rsi,%rbx
mov    %rdx,0x30(%rsp)
lea    0x1(%r13),%r14
lea    0x1(%r13),%r15d
mov    %r14,%rbp
movsbl %al,%edi
call   1090 <isspace@plt>
test   %rax,%rax
je     1217 <get_key_value+0x87>
movzbl 0x0(%rbp),%eax
add    $0x1,%rbp
add    $0x1,%r14
add    $0x1,%r15
test   %al,%al
jne    11d0 <get_key_value+0x40>
jmp    1205 <get_key_value+0x75>
lea    0xe6d(%rip),%rdi
call   1050 <puts@plt>
mov    $0xffffffff,%r12d
mov    %r12d,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    -0x1(%rbp),%al
test   %al,%al
je     1205 <get_key_value+0x75>
cmp    $0x23,%al
je     1205 <get_key_value+0x75>
cmp    $0x5b,%al
jne    124a <get_key_value+0xba>
mov    %rbp,%rax
nopl   0x0(%rax)
movzbl (%rax),%ecx
test   %cl,%cl
je     12d6 <get_key_value+0x146>
cmp    $0x5d,%cl
je     12e2 <get_key_value+0x152>
add    $0x1,%rax
jmp    1230 <get_key_value+0xa0>
mov    %rbx,0x28(%rsp)
lea    -0x1(%rbp),%rcx
mov    %rcx,0x20(%rsp)
xor    %r12d,%r12d
xor    %ebx,%ebx
nopl   (%rax)
movsbl %al,%edi
call   1080 <isalnum@plt>
test   %rax,%rax
je     128c <get_key_value+0xfc>
movzbl 0x0(%rbp,%rbx,1),%eax
add    $0x1,%rbx
movabs $0x100000000,%rcx
add    %rcx,%r12
test   %al,%al
jne    1260 <get_key_value+0xd0>
jmp    13d8 <get_key_value+0x248>
mov    -0x1(%rbp,%rbx,1),%al
test   %al,%al
je     13d8 <get_key_value+0x248>
add    %rbx,%rbp
add    %rbx,%r15
add    %rbx,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1090 <isspace@plt>
test   %rax,%rax
je     131b <get_key_value+0x18b>
movzbl 0x0(%rbp),%eax
add    $0x1,%rbp
add    $0x1,%r14
add    $0x1,%r15
test   %al,%al
jne    12b0 <get_key_value+0x120>
jmp    13d8 <get_key_value+0x248>
lea    0xd23(%rip),%rdi
jmp    13df <get_key_value+0x24f>
movb   $0x0,(%rax)
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    $0x5,%edi
call   10b0 <malloc@plt>
mov    %rax,(%rbx)
test   %rax,%rax
je     130f <get_key_value+0x17f>
mov    %rax,%rdi
mov    %rbp,%rsi
call   1040 <strcpy@plt>
jmp    1205 <get_key_value+0x75>
lea    0xd3e(%rip),%rdi
jmp    11fa <get_key_value+0x6a>
cmpb   $0x3d,-0x1(%rbp)
jne    13d8 <get_key_value+0x248>
movzbl 0x0(%rbp),%eax
test   %al,%al
je     135d <get_key_value+0x1cd>
movsbl %al,%edi
call   1090 <isspace@plt>
mov    %rbp,%rcx
add    $0x1,%rbp
mov    %r14,%rsi
add    $0x1,%r14
mov    %r15,%rdx
add    $0x1,%r15
test   %rax,%rax
jne    1325 <get_key_value+0x195>
mov    -0x1(%rbp),%al
mov    %rcx,%rbp
mov    %rdx,%r15
mov    %rsi,%r14
jmp    135f <get_key_value+0x1cf>
xor    %eax,%eax
movsbl %al,%edi
call   1080 <isalnum@plt>
test   %rax,%rax
je     13d8 <get_key_value+0x248>
mov    0x0(%rbp),%al
cmp    $0x23,%al
je     13d8 <get_key_value+0x248>
mov    %r14,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %rbp,%r15
test   %al,%al
mov    %rbp,0x8(%rsp)
je     13bd <get_key_value+0x22d>
add    $0x1,%rbp
xor    %r14d,%r14d
movsbl %al,%edi
call   1080 <isalnum@plt>
movzbl -0x1(%rbp),%ecx
test   %rax,%rax
je     13cc <get_key_value+0x23c>
cmp    $0x23,%cl
je     13d1 <get_key_value+0x241>
movzbl 0x0(%rbp),%eax
add    $0x1,%rbp
add    $0x1,%r14
test   %al,%al
jne    1390 <get_key_value+0x200>
add    $0xffffffffffffffff,%rbp
mov    %rbp,%r15
mov    %r15,%r14
sub    0x10(%rsp),%r14
sub    0x18(%rsp),%r15d
jmp    1413 <get_key_value+0x283>
mov    %r14d,%r15d
jmp    13ee <get_key_value+0x25e>
mov    $0x23,%cl
mov    %r14d,%r15d
jmp    13f2 <get_key_value+0x262>
lea    0xc39(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    11ff <get_key_value+0x6f>
test   %cl,%cl
je     1413 <get_key_value+0x283>
movsbl %cl,%edi
call   1090 <isspace@plt>
test   %rax,%rax
je     1408 <get_key_value+0x278>
mov    0x0(%rbp),%cl
add    $0x1,%rbp
jmp    13ee <get_key_value+0x25e>
mov    -0x1(%rbp),%al
test   %al,%al
je     1413 <get_key_value+0x283>
cmp    $0x23,%al
jne    13d8 <get_key_value+0x248>
lea    0x1(%rbx),%edi
call   10b0 <malloc@plt>
mov    0x28(%rsp),%rbp
mov    %rax,0x0(%rbp)
test   %rax,%rax
je     1484 <get_key_value+0x2f4>
lea    0x1(%r15),%edi
call   10b0 <malloc@plt>
mov    0x30(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x0(%rbp),%rdi
test   %rax,%rax
je     1490 <get_key_value+0x300>
mov    0x20(%rsp),%rsi
mov    %r15,%r13
mov    %rcx,%r15
mov    %ebx,%edx
call   10a0 <memcpy@plt>
mov    (%r15),%rdi
mov    0x8(%rsp),%rsi
mov    %r13d,%edx
call   10a0 <memcpy@plt>
mov    0x0(%rbp),%rax
sar    $0x20,%r12
movb   $0x0,(%rax,%r12,1)
mov    (%r15),%rax
movslq %r14d,%rcx
movb   $0x0,(%rax,%rcx,1)
xor    %r12d,%r12d
jmp    1205 <get_key_value+0x75>
lea    0xbb4(%rip),%rdi
jmp    11fa <get_key_value+0x6a>
call   1030 <free@plt>
movq   $0x0,0x0(%rbp)
lea    0xb86(%rip),%rdi
jmp    11fa <get_key_value+0x6a>

LLVM IR (-O0):
@.str = [13 x i8] c"buf is null\0A\00"
@.str.1 = [24 x i8] c"invalid line, line[%s]\0A\00"
@.str.2 = [20 x i8] c"malloc key failed.\0A\00"
@.str.3 = [18 x i8] c"invalid line[%s]\0A\00"
@.str.4 = [22 x i8] c"malloc ppkey failed.\0A\00"
@.str.5 = [22 x i8] c"malloc ppval failed.\0A\00"
define i32 @get_key_value(i8* %0, i8** %1, i8** %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8**
%7 = alloca i8**
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
store i8* %0, i8** %5
store i8** %1, i8*** %6
store i8** %2, i8*** %7
%14 = load i8*, i8** %5
store i8* %14, i8** %11
%15 = load i8**, i8*** %7
store i8* null, i8** %15
%16 = load i8**, i8*** %6
store i8* null, i8** %16
%17 = load i8*, i8** %11
%18 = icmp eq i8* %17, null
br i1 %18, label %19, label %21
19: ; preds = %3
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0))
store i32 -1, i32* %4
br label %287
21: ; preds = %3
br label %22
22: ; preds = %35, %21
%23 = load i8*, i8** %11
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %32
27: ; preds = %22
%28 = load i8*, i8** %11
%29 = load i8, i8* %28
%30 = call i64 @isspace(i8 signext %29)
%31 = icmp ne i64 %30, 0
br label %32
32: ; preds = %27, %22
%33 = phi i1 [ false, %22 ], [ %31, %27 ]
br i1 %33, label %34, label %38
34: ; preds = %32
br label %35
35: ; preds = %34
%36 = load i8*, i8** %11
%37 = getelementptr inbounds i8, i8* %36, i32 1
store i8* %37, i8** %11
br label %22
38: ; preds = %32
%39 = load i8*, i8** %11
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp eq i32 %41, 0
br i1 %42, label %48, label %43
43: ; preds = %38
%44 = load i8*, i8** %11
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
%47 = icmp eq i32 %46, 35
br i1 %47, label %48, label %49
48: ; preds = %43, %38
store i32 0, i32* %4
br label %287
49: ; preds = %43
%50 = load i8*, i8** %11
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = icmp eq i32 %52, 91
br i1 %53, label %54, label %98
54: ; preds = %49
%55 = load i8*, i8** %11
%56 = getelementptr inbounds i8, i8* %55, i32 1
store i8* %56, i8** %11
store i8* %56, i8** %9
br label %57
57: ; preds = %69, %54
%58 = load i8*, i8** %11
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp ne i32 %60, 0
br i1 %61, label %62, label %67
62: ; preds = %57
%63 = load i8*, i8** %11
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp ne i32 %65, 93
br label %67
67: ; preds = %62, %57
%68 = phi i1 [ false, %57 ], [ %66, %62 ]
br i1 %68, label %69, label %72
69: ; preds = %67
%70 = load i8*, i8** %11
%71 = getelementptr inbounds i8, i8* %70, i32 1
store i8* %71, i8** %11
br label %57
72: ; preds = %67
%73 = load i8*, i8** %11
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = icmp eq i32 %75, 93
br i1 %76, label %77, label %79
77: ; preds = %72
%78 = load i8*, i8** %11
store i8 0, i8* %78
br label %82
79: ; preds = %72
%80 = load i8*, i8** %5
%81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), i8* %80)
store i32 -1, i32* %4
br label %287
82: ; preds = %77
%83 = load i8*, i8** %9
%84 = call i32 @strlen(i8* %83)
store i32 %84, i32* %12
%85 = call i64 @malloc(i32 5)
%86 = inttoptr i64 %85 to i8*
%87 = load i8**, i8*** %6
store i8* %86, i8** %87
%88 = load i8**, i8*** %6
%89 = load i8*, i8** %88
%90 = icmp eq i8* %89, null
br i1 %90, label %91, label %93
91: ; preds = %82
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0))
store i32 -1, i32* %4
br label %287
93: ; preds = %82
%94 = load i8**, i8*** %6
%95 = load i8*, i8** %94
%96 = load i8*, i8** %9
%97 = call i32 @strcpy(i8* %95, i8* %96)
store i32 0, i32* %4
br label %287
98: ; preds = %49
%99 = load i8*, i8** %11
store i8* %99, i8** %9
br label %100
100: ; preds = %112, %98
%101 = load i8*, i8** %11
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %110
105: ; preds = %100
%106 = load i8*, i8** %11
%107 = load i8, i8* %106
%108 = call i64 @isalnum(i8 signext %107)
%109 = icmp ne i64 %108, 0
br label %110
110: ; preds = %105, %100
%111 = phi i1 [ false, %100 ], [ %109, %105 ]
br i1 %111, label %112, label %115
112: ; preds = %110
%113 = load i8*, i8** %11
%114 = getelementptr inbounds i8, i8* %113, i32 1
store i8* %114, i8** %11
br label %100
115: ; preds = %110
%116 = load i8*, i8** %11
%117 = load i8, i8* %116
%118 = sext i8 %117 to i32
%119 = icmp eq i32 %118, 0
br i1 %119, label %120, label %123
120: ; preds = %115
%121 = load i8*, i8** %5
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %121)
store i32 -1, i32* %4
br label %287
123: ; preds = %115
%124 = load i8*, i8** %11
%125 = load i8*, i8** %9
%126 = ptrtoint i8* %124 to i64
%127 = ptrtoint i8* %125 to i64
%128 = sub i64 %126, %127
%129 = trunc i64 %128 to i32
store i32 %129, i32* %12
br label %130
130: ; preds = %142, %123
%131 = load i8*, i8** %11
%132 = load i8, i8* %131
%133 = sext i8 %132 to i32
%134 = icmp ne i32 %133, 0
br i1 %134, label %135, label %140
135: ; preds = %130
%136 = load i8*, i8** %11
%137 = load i8, i8* %136
%138 = call i64 @isspace(i8 signext %137)
%139 = icmp ne i64 %138, 0
br label %140
140: ; preds = %135, %130
%141 = phi i1 [ false, %130 ], [ %139, %135 ]
br i1 %141, label %142, label %145
142: ; preds = %140
%143 = load i8*, i8** %11
%144 = getelementptr inbounds i8, i8* %143, i32 1
store i8* %144, i8** %11
br label %130
145: ; preds = %140
%146 = load i8*, i8** %11
%147 = getelementptr inbounds i8, i8* %146, i32 1
store i8* %147, i8** %11
%148 = load i8, i8* %146
%149 = sext i8 %148 to i32
%150 = icmp ne i32 %149, 61
br i1 %150, label %151, label %154
151: ; preds = %145
%152 = load i8*, i8** %5
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %152)
store i32 -1, i32* %4
br label %287
154: ; preds = %145
br label %155
155: ; preds = %167, %154
%156 = load i8*, i8** %11
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
%159 = icmp ne i32 %158, 0
br i1 %159, label %160, label %165
160: ; preds = %155
%161 = load i8*, i8** %11
%162 = load i8, i8* %161
%163 = call i64 @isspace(i8 signext %162)
%164 = icmp ne i64 %163, 0
br label %165
165: ; preds = %160, %155
%166 = phi i1 [ false, %155 ], [ %164, %160 ]
br i1 %166, label %167, label %170
167: ; preds = %165
%168 = load i8*, i8** %11
%169 = getelementptr inbounds i8, i8* %168, i32 1
store i8* %169, i8** %11
br label %155
170: ; preds = %165
%171 = load i8*, i8** %11
%172 = load i8, i8* %171
%173 = call i64 @isalnum(i8 signext %172)
%174 = icmp ne i64 %173, 0
br i1 %174, label %175, label %180
175: ; preds = %170
%176 = load i8*, i8** %11
%177 = load i8, i8* %176
%178 = sext i8 %177 to i32
%179 = icmp eq i32 %178, 35
br i1 %179, label %180, label %183
180: ; preds = %175, %170
%181 = load i8*, i8** %5
%182 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %181)
store i32 -1, i32* %4
br label %287
183: ; preds = %175
%184 = load i8*, i8** %11
store i8* %184, i8** %10
br label %185
185: ; preds = %202, %183
%186 = load i8*, i8** %11
%187 = load i8, i8* %186
%188 = sext i8 %187 to i32
%189 = icmp ne i32 %188, 0
br i1 %189, label %190, label %200
190: ; preds = %185
%191 = load i8*, i8** %11
%192 = load i8, i8* %191
%193 = call i64 @isalnum(i8 signext %192)
%194 = icmp ne i64 %193, 0
br i1 %194, label %195, label %200
195: ; preds = %190
%196 = load i8*, i8** %11
%197 = load i8, i8* %196
%198 = sext i8 %197 to i32
%199 = icmp ne i32 %198, 35
br label %200
200: ; preds = %195, %190, %185
%201 = phi i1 [ false, %190 ], [ false, %185 ], [ %199, %195 ]
br i1 %201, label %202, label %205
202: ; preds = %200
%203 = load i8*, i8** %11
%204 = getelementptr inbounds i8, i8* %203, i32 1
store i8* %204, i8** %11
br label %185
205: ; preds = %200
%206 = load i8*, i8** %11
%207 = load i8*, i8** %10
%208 = ptrtoint i8* %206 to i64
%209 = ptrtoint i8* %207 to i64
%210 = sub i64 %208, %209
%211 = trunc i64 %210 to i32
store i32 %211, i32* %13
br label %212
212: ; preds = %224, %205
%213 = load i8*, i8** %11
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %215, 0
br i1 %216, label %217, label %222
217: ; preds = %212
%218 = load i8*, i8** %11
%219 = load i8, i8* %218
%220 = call i64 @isspace(i8 signext %219)
%221 = icmp ne i64 %220, 0
br label %222
222: ; preds = %217, %212
%223 = phi i1 [ false, %212 ], [ %221, %217 ]
br i1 %223, label %224, label %227
224: ; preds = %222
%225 = load i8*, i8** %11
%226 = getelementptr inbounds i8, i8* %225, i32 1
store i8* %226, i8** %11
br label %212
227: ; preds = %222
%228 = load i8*, i8** %11
%229 = load i8, i8* %228
%230 = sext i8 %229 to i32
%231 = icmp ne i32 %230, 0
br i1 %231, label %232, label %240
232: ; preds = %227
%233 = load i8*, i8** %11
%234 = load i8, i8* %233
%235 = sext i8 %234 to i32
%236 = icmp ne i32 %235, 35
br i1 %236, label %237, label %240
237: ; preds = %232
%238 = load i8*, i8** %5
%239 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %238)
store i32 -1, i32* %4
br label %287
240: ; preds = %232, %227
%241 = load i32, i32* %12
%242 = add nsw i32 %241, 1
%243 = call i64 @malloc(i32 %242)
%244 = inttoptr i64 %243 to i8*
%245 = load i8**, i8*** %6
store i8* %244, i8** %245
%246 = load i8**, i8*** %6
%247 = load i8*, i8** %246
%248 = icmp eq i8* %247, null
br i1 %248, label %249, label %251
249: ; preds = %240
%250 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0))
store i32 -1, i32* %4
br label %287
251: ; preds = %240
%252 = load i32, i32* %13
%253 = add nsw i32 %252, 1
%254 = call i64 @malloc(i32 %253)
%255 = inttoptr i64 %254 to i8*
%256 = load i8**, i8*** %7
store i8* %255, i8** %256
%257 = load i8**, i8*** %7
%258 = load i8*, i8** %257
%259 = icmp eq i8* %258, null
br i1 %259, label %260, label %266
260: ; preds = %251
%261 = load i8**, i8*** %6
%262 = load i8*, i8** %261
%263 = call i32 @free(i8* %262)
%264 = load i8**, i8*** %6
store i8* null, i8** %264
%265 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.5, i64 0, i64 0))
store i32 -1, i32* %4
br label %287
266: ; preds = %251
%267 = load i8**, i8*** %6
%268 = load i8*, i8** %267
%269 = load i8*, i8** %9
%270 = load i32, i32* %12
%271 = call i32 @memcpy(i8* %268, i8* %269, i32 %270)
%272 = load i8**, i8*** %7
%273 = load i8*, i8** %272
%274 = load i8*, i8** %10
%275 = load i32, i32* %13
%276 = call i32 @memcpy(i8* %273, i8* %274, i32 %275)
%277 = load i8**, i8*** %6
%278 = load i8*, i8** %277
%279 = load i32, i32* %12
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i8, i8* %278, i64 %280
store i8 0, i8* %281
%282 = load i8**, i8*** %7
%283 = load i8*, i8** %282
%284 = load i32, i32* %13
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i8, i8* %283, i64 %285
store i8 0, i8* %286
store i32 0, i32* %4
br label %287
287: ; preds = %266, %260, %249, %237, %180, %151, %120, %93, %91, %79, %48, %19
%288 = load i32, i32* %4
ret i32 %288
}

LLVM IR (-O2):
@.str.1 = [24 x i8] c"invalid line, line[%s]\0A\00"
@.str.3 = [18 x i8] c"invalid line[%s]\0A\00"
@str = [21 x i8] c"malloc ppval failed.\00"
@str.6 = [21 x i8] c"malloc ppkey failed.\00"
@str.7 = [19 x i8] c"malloc key failed.\00"
@str.8 = [12 x i8] c"buf is null\00"
define i32 @get_key_value(i8* %0, i8** nocapture %1, i8** nocapture %2) {
store i8* null, i8** %2
store i8* null, i8** %1
%4 = icmp eq i8* %0, null
br i1 %4, label %8, label %5
5: ; preds = %3
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 0
br i1 %7, label %166, label %10
8: ; preds = %3
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.8, i64 0, i64 0))
br label %166
10: ; preds = %5, %15
%11 = phi i8 [ %17, %15 ], [ %6, %5 ]
%12 = phi i8* [ %16, %15 ], [ %0, %5 ]
%13 = tail call i64 @isspace(i8 signext %11)
%14 = icmp eq i64 %13, 0
br i1 %14, label %19, label %15
15: ; preds = %10
%16 = getelementptr inbounds i8, i8* %12, i64 1
%17 = load i8, i8* %16
%18 = icmp eq i8 %17, 0
br i1 %18, label %166, label %10
19: ; preds = %10
%20 = load i8, i8* %12
switch i8 %20, label %39 [
i8 0, label %166
i8 35, label %166
i8 91, label %21
]
21: ; preds = %19
%22 = getelementptr inbounds i8, i8* %12, i64 1
br label %23
23: ; preds = %26, %21
%24 = phi i8* [ %22, %21 ], [ %27, %26 ]
%25 = load i8, i8* %24
switch i8 %25, label %26 [
i8 93, label %28
i8 0, label %33
]
26: ; preds = %23
%27 = getelementptr inbounds i8, i8* %24, i64 1
br label %23
28: ; preds = %23
store i8 0, i8* %24
%29 = tail call i32 @strlen(i8* %22)
%30 = tail call i64 @malloc(i32 5)
%31 = inttoptr i64 %30 to i8*
store i8* %31, i8** %1
%32 = icmp eq i64 %30, 0
br i1 %32, label %35, label %37
33: ; preds = %23
%34 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %166
35: ; preds = %28
%36 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.7, i64 0, i64 0))
br label %166
37: ; preds = %28
%38 = tail call i32 @strcpy(i8* %31, i8* %22)
br label %166
39: ; preds = %19, %44
%40 = phi i8* [ %45, %44 ], [ %12, %19 ]
%41 = phi i8 [ %46, %44 ], [ %20, %19 ]
%42 = tail call i64 @isalnum(i8 signext %41)
%43 = icmp eq i64 %42, 0
br i1 %43, label %48, label %44
44: ; preds = %39
%45 = getelementptr inbounds i8, i8* %40, i64 1
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 0
br i1 %47, label %51, label %39
48: ; preds = %39
%49 = load i8, i8* %40
%50 = icmp eq i8 %49, 0
br i1 %50, label %51, label %53
51: ; preds = %44, %48
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %0)
br label %166
53: ; preds = %48
%54 = ptrtoint i8* %40 to i64
%55 = ptrtoint i8* %12 to i64
%56 = sub i64 %54, %55
%57 = trunc i64 %56 to i32
br label %58
58: ; preds = %53, %63
%59 = phi i8 [ %65, %63 ], [ %49, %53 ]
%60 = phi i8* [ %64, %63 ], [ %40, %53 ]
%61 = tail call i64 @isspace(i8 signext %59)
%62 = icmp eq i64 %61, 0
br i1 %62, label %67, label %63
63: ; preds = %58
%64 = getelementptr inbounds i8, i8* %60, i64 1
%65 = load i8, i8* %64
%66 = icmp eq i8 %65, 0
br i1 %66, label %70, label %58
67: ; preds = %58
%68 = load i8, i8* %60
%69 = icmp eq i8 %68, 61
br i1 %69, label %72, label %70
70: ; preds = %63, %67
%71 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %0)
br label %166
72: ; preds = %67, %77
%73 = phi i8* [ %74, %77 ], [ %60, %67 ]
%74 = getelementptr inbounds i8, i8* %73, i64 1
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 0
br i1 %76, label %82, label %77
77: ; preds = %72
%78 = tail call i64 @isspace(i8 signext %75)
%79 = icmp eq i64 %78, 0
br i1 %79, label %80, label %72
80: ; preds = %77
%81 = load i8, i8* %74
br label %82
82: ; preds = %72, %80
%83 = phi i8 [ %81, %80 ], [ 0, %72 ]
%84 = tail call i64 @isalnum(i8 signext %83)
%85 = icmp eq i64 %84, 0
br i1 %85, label %88, label %86
86: ; preds = %82
%87 = load i8, i8* %74
switch i8 %87, label %90 [
i8 35, label %88
i8 0, label %107
]
88: ; preds = %86, %82
%89 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %0)
br label %166
90: ; preds = %86, %103
%91 = phi i8* [ %104, %103 ], [ %74, %86 ]
%92 = phi i8 [ %105, %103 ], [ %87, %86 ]
%93 = tail call i64 @isalnum(i8 signext %92)
%94 = icmp eq i64 %93, 0
%95 = load i8, i8* %91
br i1 %94, label %113, label %96
96: ; preds = %90
%97 = icmp eq i8 %95, 35
br i1 %97, label %98, label %103
98: ; preds = %96
%99 = ptrtoint i8* %91 to i64
%100 = ptrtoint i8* %74 to i64
%101 = sub i64 %99, %100
%102 = trunc i64 %101 to i32
br label %119
103: ; preds = %96
%104 = getelementptr inbounds i8, i8* %91, i64 1
%105 = load i8, i8* %104
%106 = icmp eq i8 %105, 0
br i1 %106, label %107, label %90
107: ; preds = %103, %86
%108 = phi i8* [ %74, %86 ], [ %104, %103 ]
%109 = ptrtoint i8* %108 to i64
%110 = ptrtoint i8* %74 to i64
%111 = sub i64 %109, %110
%112 = trunc i64 %111 to i32
br label %136
113: ; preds = %90
%114 = ptrtoint i8* %91 to i64
%115 = ptrtoint i8* %74 to i64
%116 = sub i64 %114, %115
%117 = trunc i64 %116 to i32
%118 = icmp eq i8 %95, 0
br i1 %118, label %136, label %119
119: ; preds = %98, %113
%120 = phi i32 [ %102, %98 ], [ %117, %113 ]
%121 = phi i64 [ %101, %98 ], [ %116, %113 ]
%122 = phi i8 [ 35, %98 ], [ %95, %113 ]
br label %123
123: ; preds = %119, %128
%124 = phi i8 [ %130, %128 ], [ %122, %119 ]
%125 = phi i8* [ %129, %128 ], [ %91, %119 ]
%126 = tail call i64 @isspace(i8 signext %124)
%127 = icmp eq i64 %126, 0
br i1 %127, label %132, label %128
128: ; preds = %123
%129 = getelementptr inbounds i8, i8* %125, i64 1
%130 = load i8, i8* %129
%131 = icmp eq i8 %130, 0
br i1 %131, label %136, label %123
132: ; preds = %123
%133 = load i8, i8* %125
switch i8 %133, label %134 [
i8 0, label %136
i8 35, label %136
]
134: ; preds = %132
%135 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.3, i64 0, i64 0), i8* %0)
br label %166
136: ; preds = %128, %107, %113, %132, %132
%137 = phi i32 [ %112, %107 ], [ %117, %113 ], [ %120, %132 ], [ %120, %132 ], [ %120, %128 ]
%138 = phi i64 [ %111, %107 ], [ %116, %113 ], [ %121, %132 ], [ %121, %132 ], [ %121, %128 ]
%139 = add nsw i32 %57, 1
%140 = tail call i64 @malloc(i32 %139)
%141 = inttoptr i64 %140 to i8*
store i8* %141, i8** %1
%142 = icmp eq i64 %140, 0
br i1 %142, label %143, label %145
143: ; preds = %136
%144 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.6, i64 0, i64 0))
br label %166
145: ; preds = %136
%146 = add nsw i32 %137, 1
%147 = tail call i64 @malloc(i32 %146)
%148 = inttoptr i64 %147 to i8*
store i8* %148, i8** %2
%149 = icmp eq i64 %147, 0
%150 = load i8*, i8** %1
br i1 %149, label %151, label %154
151: ; preds = %145
%152 = tail call i32 @free(i8* %150)
store i8* null, i8** %1
%153 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str, i64 0, i64 0))
br label %166
154: ; preds = %145
%155 = tail call i32 @memcpy(i8* %150, i8* %12, i32 %57)
%156 = load i8*, i8** %2
%157 = tail call i32 @memcpy(i8* %156, i8* %74, i32 %137)
%158 = load i8*, i8** %1
%159 = shl i64 %56, 32
%160 = ashr exact i64 %159, 32
%161 = getelementptr inbounds i8, i8* %158, i64 %160
store i8 0, i8* %161
%162 = load i8*, i8** %2
%163 = shl i64 %138, 32
%164 = ashr exact i64 %163, 32
%165 = getelementptr inbounds i8, i8* %162, i64 %164
store i8 0, i8* %165
br label %166
166: ; preds = %15, %5, %19, %19, %154, %151, %143, %134, %88, %70, %51, %37, %35, %33, %8
%167 = phi i32 [ -1, %8 ], [ -1, %35 ], [ 0, %37 ], [ -1, %33 ], [ -1, %51 ], [ -1, %70 ], [ -1, %88 ], [ -1, %134 ], [ -1, %143 ], [ -1, %151 ], [ 0, %154 ], [ 0, %19 ], [ 0, %19 ], [ 0, %5 ], [ 0, %15 ]
ret i32 %167
}