#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 */

/* Variables and functions */
scalar_t__ B_TempAlloc(int);
int /*<<< orphan*/ strcpy(char *, char *);
char *GetFlagStr(int flags) {
  char *flagstr;
  int i;
  flagstr = (char *)B_TempAlloc(128);
  i = 0;
  if (!flags) {
    strcpy(flagstr, "none\0");
    goto fend;
  }
  if (flags & 0x00000010) {
    flagstr[i] = 'j';
    i++;
  }
  if (flags & 0x00000020) {
    flagstr[i] = 'd';
    i++;
  }
  if (flags & 0x00000800) {
    flagstr[i] = 'c';
    i++;
  }
  if (flags & 0x00001000) {
    flagstr[i] = 'f';
    i++;
  }
  if (flags & 0x00002000) {
    flagstr[i] = 's';
    i++;
  }
  if (flags & 0x00004000) {
    flagstr[i] = 'x';
    i++;
  }
  if (flags & 0x00008000) {
    flagstr[i] = 'y';
    i++;
  }
  if (flags & 0x00010000) {
    flagstr[i] = 'g';
    i++;
  }
  if (flags & 0x00000400) {
    flagstr[i] = 'n';
    i++;
  }
  if (flags & 0x00200000) {
    flagstr[i] = 'm';
    i++;
  }
  if (flags & 0x00020000) {
    if (i) {
      flagstr[i] = ' ';
      i++;
    }
    flagstr[i] = 'r';
    i++;
    flagstr[i] = 'e';
    i++;
    flagstr[i] = 'd';
    i++;
    flagstr[i] = ' ';
    i++;
    flagstr[i] = 'f';
    i++;
    flagstr[i] = 'l';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = 'g';
    i++;
  }
  if (flags & 0x00040000) {
    if (i) {
      flagstr[i] = ' ';
      i++;
    }
    flagstr[i] = 'b';
    i++;
    flagstr[i] = 'l';
    i++;
    flagstr[i] = 'u';
    i++;
    flagstr[i] = 'e';
    i++;
    flagstr[i] = ' ';
    i++;
    flagstr[i] = 'f';
    i++;
    flagstr[i] = 'l';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = 'g';
    i++;
  }
  if (flags & 0x00100000) {
    if (i) {
      flagstr[i] = ' ';
      i++;
    }
    flagstr[i] = 's';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = 'g';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = '_';
    i++;
    flagstr[i] = 'i';
    i++;
    flagstr[i] = 'm';
    i++;
    flagstr[i] = 'p';
    i++;
  }
  if (flags & 0x00080000) {
    if (i) {
      flagstr[i] = ' ';
      i++;
    }
    flagstr[i] = 's';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = 'g';
    i++;
    flagstr[i] = 'a';
    i++;
    flagstr[i] = '_';
    i++;
    flagstr[i] = 'r';
    i++;
    flagstr[i] = 'e';
    i++;
    flagstr[i] = 'b';
    i++;
  }
  flagstr[i] = '\0';
  if (i == 0) {
    strcpy(flagstr, "unknown\0");
  }
fend:
  return flagstr;
}


x86 assembly (clang, -O0):
<GetFlagStr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    $0x80,%edi
call   1040 <B_TempAlloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    115f <GetFlagStr+0x3f>
mov    -0x10(%rbp),%rdi
lea    0xeab(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <GetFlagStr+0x557>
mov    -0x4(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1183 <GetFlagStr+0x63>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6a,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     11a7 <GetFlagStr+0x87>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x64,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x800,%eax
cmp    $0x0,%eax
je     11cd <GetFlagStr+0xad>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x63,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x1000,%eax
cmp    $0x0,%eax
je     11f3 <GetFlagStr+0xd3>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x66,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x2000,%eax
cmp    $0x0,%eax
je     1219 <GetFlagStr+0xf9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x73,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x4000,%eax
cmp    $0x0,%eax
je     123f <GetFlagStr+0x11f>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x78,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x8000,%eax
cmp    $0x0,%eax
je     1265 <GetFlagStr+0x145>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x79,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x10000,%eax
cmp    $0x0,%eax
je     128b <GetFlagStr+0x16b>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x400,%eax
cmp    $0x0,%eax
je     12b1 <GetFlagStr+0x191>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6e,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x200000,%eax
cmp    $0x0,%eax
je     12d7 <GetFlagStr+0x1b7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6d,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x20000,%eax
cmp    $0x0,%eax
je     13af <GetFlagStr+0x28f>
cmpl   $0x0,-0x14(%rbp)
je     1307 <GetFlagStr+0x1e7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x72,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x64,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x66,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6c,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x40000,%eax
cmp    $0x0,%eax
je     149c <GetFlagStr+0x37c>
cmpl   $0x0,-0x14(%rbp)
je     13df <GetFlagStr+0x2bf>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x62,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6c,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x75,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x66,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6c,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x100000,%eax
cmp    $0x0,%eax
je     1574 <GetFlagStr+0x454>
cmpl   $0x0,-0x14(%rbp)
je     14cc <GetFlagStr+0x3ac>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x73,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x5f,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x69,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x6d,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x70,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x4(%rbp),%eax
and    $0x80000,%eax
cmp    $0x0,%eax
je     164c <GetFlagStr+0x52c>
cmpl   $0x0,-0x14(%rbp)
je     15a4 <GetFlagStr+0x484>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x73,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x5f,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x72,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x65,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x62,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
cmpl   $0x0,-0x14(%rbp)
jne    1672 <GetFlagStr+0x552>
mov    -0x10(%rbp),%rdi
lea    0x999(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <GetFlagStr+0x557>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GetFlagStr>:
push   %rbp
push   %rbx
push   %rax
mov    %edi,%ebp
mov    $0x80,%edi
call   1040 <B_TempAlloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
je     11f7 <GetFlagStr+0xd7>
xor    %eax,%eax
test   $0x10,%bpl
jne    120b <GetFlagStr+0xeb>
test   $0x20,%bpl
jne    121d <GetFlagStr+0xfd>
test   $0x800,%ebp
jne    1232 <GetFlagStr+0x112>
test   $0x1000,%ebp
jne    1247 <GetFlagStr+0x127>
test   $0x2000,%ebp
jne    125c <GetFlagStr+0x13c>
test   $0x4000,%ebp
jne    1271 <GetFlagStr+0x151>
test   $0x8000,%ebp
jne    1286 <GetFlagStr+0x166>
test   $0x10000,%ebp
jne    129b <GetFlagStr+0x17b>
test   $0x400,%ebp
jne    12b0 <GetFlagStr+0x190>
test   $0x200000,%ebp
jne    12c5 <GetFlagStr+0x1a5>
test   $0x20000,%ebp
jne    12da <GetFlagStr+0x1ba>
test   $0x40000,%ebp
jne    130a <GetFlagStr+0x1ea>
test   $0x100000,%ebp
jne    133f <GetFlagStr+0x21f>
test   $0x80000,%ebp
jne    136f <GetFlagStr+0x24f>
mov    %eax,%ecx
movb   $0x0,(%rbx,%rcx,1)
test   %eax,%eax
jne    1395 <GetFlagStr+0x275>
lea    0xe11(%rip),%rsi
jmp    11fe <GetFlagStr+0xde>
lea    0xe02(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
jmp    1395 <GetFlagStr+0x275>
movb   $0x6a,(%rbx)
mov    $0x1,%eax
test   $0x20,%bpl
je     1150 <GetFlagStr+0x30>
mov    %eax,%ecx
movb   $0x64,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x800,%ebp
je     115c <GetFlagStr+0x3c>
mov    %eax,%ecx
movb   $0x63,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x1000,%ebp
je     1168 <GetFlagStr+0x48>
mov    %eax,%ecx
movb   $0x66,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x2000,%ebp
je     1174 <GetFlagStr+0x54>
mov    %eax,%ecx
movb   $0x73,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x4000,%ebp
je     1180 <GetFlagStr+0x60>
mov    %eax,%ecx
movb   $0x78,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x8000,%ebp
je     118c <GetFlagStr+0x6c>
mov    %eax,%ecx
movb   $0x79,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x10000,%ebp
je     1198 <GetFlagStr+0x78>
mov    %eax,%ecx
movb   $0x67,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x400,%ebp
je     11a4 <GetFlagStr+0x84>
mov    %eax,%ecx
movb   $0x6e,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x200000,%ebp
je     11b0 <GetFlagStr+0x90>
mov    %eax,%ecx
movb   $0x6d,(%rbx,%rcx,1)
add    $0x1,%eax
test   $0x20000,%ebp
je     11bc <GetFlagStr+0x9c>
test   %eax,%eax
je     12e9 <GetFlagStr+0x1c9>
mov    %eax,%ecx
movb   $0x20,(%rbx,%rcx,1)
add    $0x1,%eax
jmp    12eb <GetFlagStr+0x1cb>
xor    %eax,%eax
mov    %eax,%ecx
movabs $0x67616c6620646572,%rdx
6c 61 67
mov    %rdx,(%rbx,%rcx,1)
add    $0x8,%eax
test   $0x40000,%ebp
je     11c8 <GetFlagStr+0xa8>
test   %eax,%eax
je     1319 <GetFlagStr+0x1f9>
mov    %eax,%ecx
movb   $0x20,(%rbx,%rcx,1)
add    $0x1,%eax
jmp    131b <GetFlagStr+0x1fb>
xor    %eax,%eax
mov    %eax,%ecx
movabs $0x616c662065756c62,%rdx
66 6c 61
mov    %rdx,(%rbx,%rcx,1)
movb   $0x67,0x8(%rbx,%rcx,1)
add    $0x9,%eax
test   $0x100000,%ebp
je     11d4 <GetFlagStr+0xb4>
test   %eax,%eax
je     134e <GetFlagStr+0x22e>
mov    %eax,%ecx
movb   $0x20,(%rbx,%rcx,1)
add    $0x1,%eax
jmp    1350 <GetFlagStr+0x230>
xor    %eax,%eax
mov    %eax,%ecx
movabs $0x706d695f61676173,%rdx
69 6d 70
mov    %rdx,(%rbx,%rcx,1)
add    $0x8,%eax
test   $0x80000,%ebp
je     11e0 <GetFlagStr+0xc0>
test   %eax,%eax
je     137e <GetFlagStr+0x25e>
mov    %eax,%ecx
movb   $0x20,(%rbx,%rcx,1)
add    $0x1,%eax
jmp    1380 <GetFlagStr+0x260>
xor    %eax,%eax
mov    %eax,%eax
movabs $0x6265725f61676173,%rcx
72 65 62
mov    %rcx,(%rbx,%rax,1)
movb   $0x0,0x8(%rbx,%rax,1)
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@.str = [6 x i8] c"none\00\00"
@.str.1 = [9 x i8] c"unknown\00\00"
define i8* @GetFlagStr(i32 %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
store i32 %0, i32* %2
%5 = call i64 @B_TempAlloc(i32 128)
%6 = inttoptr i64 %5 to i8*
store i8* %6, i8** %3
store i32 0, i32* %4
%7 = load i32, i32* %2
%8 = icmp ne i32 %7, 0
br i1 %8, label %12, label %9
9: ; preds = %1
%10 = load i8*, i8** %3
%11 = call i32 @strcpy(i8* %10, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
br label %391
12: ; preds = %1
%13 = load i32, i32* %2
%14 = and i32 %13, 16
%15 = icmp ne i32 %14, 0
br i1 %15, label %16, label %23
16: ; preds = %12
%17 = load i8*, i8** %3
%18 = load i32, i32* %4
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
store i8 106, i8* %20
%21 = load i32, i32* %4
%22 = add nsw i32 %21, 1
store i32 %22, i32* %4
br label %23
23: ; preds = %16, %12
%24 = load i32, i32* %2
%25 = and i32 %24, 32
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %34
27: ; preds = %23
%28 = load i8*, i8** %3
%29 = load i32, i32* %4
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %28, i64 %30
store i8 100, i8* %31
%32 = load i32, i32* %4
%33 = add nsw i32 %32, 1
store i32 %33, i32* %4
br label %34
34: ; preds = %27, %23
%35 = load i32, i32* %2
%36 = and i32 %35, 2048
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %45
38: ; preds = %34
%39 = load i8*, i8** %3
%40 = load i32, i32* %4
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
store i8 99, i8* %42
%43 = load i32, i32* %4
%44 = add nsw i32 %43, 1
store i32 %44, i32* %4
br label %45
45: ; preds = %38, %34
%46 = load i32, i32* %2
%47 = and i32 %46, 4096
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %56
49: ; preds = %45
%50 = load i8*, i8** %3
%51 = load i32, i32* %4
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %50, i64 %52
store i8 102, i8* %53
%54 = load i32, i32* %4
%55 = add nsw i32 %54, 1
store i32 %55, i32* %4
br label %56
56: ; preds = %49, %45
%57 = load i32, i32* %2
%58 = and i32 %57, 8192
%59 = icmp ne i32 %58, 0
br i1 %59, label %60, label %67
60: ; preds = %56
%61 = load i8*, i8** %3
%62 = load i32, i32* %4
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
store i8 115, i8* %64
%65 = load i32, i32* %4
%66 = add nsw i32 %65, 1
store i32 %66, i32* %4
br label %67
67: ; preds = %60, %56
%68 = load i32, i32* %2
%69 = and i32 %68, 16384
%70 = icmp ne i32 %69, 0
br i1 %70, label %71, label %78
71: ; preds = %67
%72 = load i8*, i8** %3
%73 = load i32, i32* %4
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %72, i64 %74
store i8 120, i8* %75
%76 = load i32, i32* %4
%77 = add nsw i32 %76, 1
store i32 %77, i32* %4
br label %78
78: ; preds = %71, %67
%79 = load i32, i32* %2
%80 = and i32 %79, 32768
%81 = icmp ne i32 %80, 0
br i1 %81, label %82, label %89
82: ; preds = %78
%83 = load i8*, i8** %3
%84 = load i32, i32* %4
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
store i8 121, i8* %86
%87 = load i32, i32* %4
%88 = add nsw i32 %87, 1
store i32 %88, i32* %4
br label %89
89: ; preds = %82, %78
%90 = load i32, i32* %2
%91 = and i32 %90, 65536
%92 = icmp ne i32 %91, 0
br i1 %92, label %93, label %100
93: ; preds = %89
%94 = load i8*, i8** %3
%95 = load i32, i32* %4
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %94, i64 %96
store i8 103, i8* %97
%98 = load i32, i32* %4
%99 = add nsw i32 %98, 1
store i32 %99, i32* %4
br label %100
100: ; preds = %93, %89
%101 = load i32, i32* %2
%102 = and i32 %101, 1024
%103 = icmp ne i32 %102, 0
br i1 %103, label %104, label %111
104: ; preds = %100
%105 = load i8*, i8** %3
%106 = load i32, i32* %4
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %105, i64 %107
store i8 110, i8* %108
%109 = load i32, i32* %4
%110 = add nsw i32 %109, 1
store i32 %110, i32* %4
br label %111
111: ; preds = %104, %100
%112 = load i32, i32* %2
%113 = and i32 %112, 2097152
%114 = icmp ne i32 %113, 0
br i1 %114, label %115, label %122
115: ; preds = %111
%116 = load i8*, i8** %3
%117 = load i32, i32* %4
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8, i8* %116, i64 %118
store i8 109, i8* %119
%120 = load i32, i32* %4
%121 = add nsw i32 %120, 1
store i32 %121, i32* %4
br label %122
122: ; preds = %115, %111
%123 = load i32, i32* %2
%124 = and i32 %123, 131072
%125 = icmp ne i32 %124, 0
br i1 %125, label %126, label %185
126: ; preds = %122
%127 = load i32, i32* %4
%128 = icmp ne i32 %127, 0
br i1 %128, label %129, label %136
129: ; preds = %126
%130 = load i8*, i8** %3
%131 = load i32, i32* %4
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %130, i64 %132
store i8 32, i8* %133
%134 = load i32, i32* %4
%135 = add nsw i32 %134, 1
store i32 %135, i32* %4
br label %136
136: ; preds = %129, %126
%137 = load i8*, i8** %3
%138 = load i32, i32* %4
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %137, i64 %139
store i8 114, i8* %140
%141 = load i32, i32* %4
%142 = add nsw i32 %141, 1
store i32 %142, i32* %4
%143 = load i8*, i8** %3
%144 = load i32, i32* %4
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %143, i64 %145
store i8 101, i8* %146
%147 = load i32, i32* %4
%148 = add nsw i32 %147, 1
store i32 %148, i32* %4
%149 = load i8*, i8** %3
%150 = load i32, i32* %4
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %149, i64 %151
store i8 100, i8* %152
%153 = load i32, i32* %4
%154 = add nsw i32 %153, 1
store i32 %154, i32* %4
%155 = load i8*, i8** %3
%156 = load i32, i32* %4
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
store i8 32, i8* %158
%159 = load i32, i32* %4
%160 = add nsw i32 %159, 1
store i32 %160, i32* %4
%161 = load i8*, i8** %3
%162 = load i32, i32* %4
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %161, i64 %163
store i8 102, i8* %164
%165 = load i32, i32* %4
%166 = add nsw i32 %165, 1
store i32 %166, i32* %4
%167 = load i8*, i8** %3
%168 = load i32, i32* %4
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8, i8* %167, i64 %169
store i8 108, i8* %170
%171 = load i32, i32* %4
%172 = add nsw i32 %171, 1
store i32 %172, i32* %4
%173 = load i8*, i8** %3
%174 = load i32, i32* %4
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8, i8* %173, i64 %175
store i8 97, i8* %176
%177 = load i32, i32* %4
%178 = add nsw i32 %177, 1
store i32 %178, i32* %4
%179 = load i8*, i8** %3
%180 = load i32, i32* %4
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %179, i64 %181
store i8 103, i8* %182
%183 = load i32, i32* %4
%184 = add nsw i32 %183, 1
store i32 %184, i32* %4
br label %185
185: ; preds = %136, %122
%186 = load i32, i32* %2
%187 = and i32 %186, 262144
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %254
189: ; preds = %185
%190 = load i32, i32* %4
%191 = icmp ne i32 %190, 0
br i1 %191, label %192, label %199
192: ; preds = %189
%193 = load i8*, i8** %3
%194 = load i32, i32* %4
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i8, i8* %193, i64 %195
store i8 32, i8* %196
%197 = load i32, i32* %4
%198 = add nsw i32 %197, 1
store i32 %198, i32* %4
br label %199
199: ; preds = %192, %189
%200 = load i8*, i8** %3
%201 = load i32, i32* %4
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
store i8 98, i8* %203
%204 = load i32, i32* %4
%205 = add nsw i32 %204, 1
store i32 %205, i32* %4
%206 = load i8*, i8** %3
%207 = load i32, i32* %4
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %206, i64 %208
store i8 108, i8* %209
%210 = load i32, i32* %4
%211 = add nsw i32 %210, 1
store i32 %211, i32* %4
%212 = load i8*, i8** %3
%213 = load i32, i32* %4
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %212, i64 %214
store i8 117, i8* %215
%216 = load i32, i32* %4
%217 = add nsw i32 %216, 1
store i32 %217, i32* %4
%218 = load i8*, i8** %3
%219 = load i32, i32* %4
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i8, i8* %218, i64 %220
store i8 101, i8* %221
%222 = load i32, i32* %4
%223 = add nsw i32 %222, 1
store i32 %223, i32* %4
%224 = load i8*, i8** %3
%225 = load i32, i32* %4
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i8, i8* %224, i64 %226
store i8 32, i8* %227
%228 = load i32, i32* %4
%229 = add nsw i32 %228, 1
store i32 %229, i32* %4
%230 = load i8*, i8** %3
%231 = load i32, i32* %4
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
store i8 102, i8* %233
%234 = load i32, i32* %4
%235 = add nsw i32 %234, 1
store i32 %235, i32* %4
%236 = load i8*, i8** %3
%237 = load i32, i32* %4
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %236, i64 %238
store i8 108, i8* %239
%240 = load i32, i32* %4
%241 = add nsw i32 %240, 1
store i32 %241, i32* %4
%242 = load i8*, i8** %3
%243 = load i32, i32* %4
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
store i8 97, i8* %245
%246 = load i32, i32* %4
%247 = add nsw i32 %246, 1
store i32 %247, i32* %4
%248 = load i8*, i8** %3
%249 = load i32, i32* %4
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i8, i8* %248, i64 %250
store i8 103, i8* %251
%252 = load i32, i32* %4
%253 = add nsw i32 %252, 1
store i32 %253, i32* %4
br label %254
254: ; preds = %199, %185
%255 = load i32, i32* %2
%256 = and i32 %255, 1048576
%257 = icmp ne i32 %256, 0
br i1 %257, label %258, label %317
258: ; preds = %254
%259 = load i32, i32* %4
%260 = icmp ne i32 %259, 0
br i1 %260, label %261, label %268
261: ; preds = %258
%262 = load i8*, i8** %3
%263 = load i32, i32* %4
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
store i8 32, i8* %265
%266 = load i32, i32* %4
%267 = add nsw i32 %266, 1
store i32 %267, i32* %4
br label %268
268: ; preds = %261, %258
%269 = load i8*, i8** %3
%270 = load i32, i32* %4
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
store i8 115, i8* %272
%273 = load i32, i32* %4
%274 = add nsw i32 %273, 1
store i32 %274, i32* %4
%275 = load i8*, i8** %3
%276 = load i32, i32* %4
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i8, i8* %275, i64 %277
store i8 97, i8* %278
%279 = load i32, i32* %4
%280 = add nsw i32 %279, 1
store i32 %280, i32* %4
%281 = load i8*, i8** %3
%282 = load i32, i32* %4
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i8, i8* %281, i64 %283
store i8 103, i8* %284
%285 = load i32, i32* %4
%286 = add nsw i32 %285, 1
store i32 %286, i32* %4
%287 = load i8*, i8** %3
%288 = load i32, i32* %4
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i8, i8* %287, i64 %289
store i8 97, i8* %290
%291 = load i32, i32* %4
%292 = add nsw i32 %291, 1
store i32 %292, i32* %4
%293 = load i8*, i8** %3
%294 = load i32, i32* %4
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i8, i8* %293, i64 %295
store i8 95, i8* %296
%297 = load i32, i32* %4
%298 = add nsw i32 %297, 1
store i32 %298, i32* %4
%299 = load i8*, i8** %3
%300 = load i32, i32* %4
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i8, i8* %299, i64 %301
store i8 105, i8* %302
%303 = load i32, i32* %4
%304 = add nsw i32 %303, 1
store i32 %304, i32* %4
%305 = load i8*, i8** %3
%306 = load i32, i32* %4
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i8, i8* %305, i64 %307
store i8 109, i8* %308
%309 = load i32, i32* %4
%310 = add nsw i32 %309, 1
store i32 %310, i32* %4
%311 = load i8*, i8** %3
%312 = load i32, i32* %4
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8, i8* %311, i64 %313
store i8 112, i8* %314
%315 = load i32, i32* %4
%316 = add nsw i32 %315, 1
store i32 %316, i32* %4
br label %317
317: ; preds = %268, %254
%318 = load i32, i32* %2
%319 = and i32 %318, 524288
%320 = icmp ne i32 %319, 0
br i1 %320, label %321, label %380
321: ; preds = %317
%322 = load i32, i32* %4
%323 = icmp ne i32 %322, 0
br i1 %323, label %324, label %331
324: ; preds = %321
%325 = load i8*, i8** %3
%326 = load i32, i32* %4
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i8, i8* %325, i64 %327
store i8 32, i8* %328
%329 = load i32, i32* %4
%330 = add nsw i32 %329, 1
store i32 %330, i32* %4
br label %331
331: ; preds = %324, %321
%332 = load i8*, i8** %3
%333 = load i32, i32* %4
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i8, i8* %332, i64 %334
store i8 115, i8* %335
%336 = load i32, i32* %4
%337 = add nsw i32 %336, 1
store i32 %337, i32* %4
%338 = load i8*, i8** %3
%339 = load i32, i32* %4
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds i8, i8* %338, i64 %340
store i8 97, i8* %341
%342 = load i32, i32* %4
%343 = add nsw i32 %342, 1
store i32 %343, i32* %4
%344 = load i8*, i8** %3
%345 = load i32, i32* %4
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %344, i64 %346
store i8 103, i8* %347
%348 = load i32, i32* %4
%349 = add nsw i32 %348, 1
store i32 %349, i32* %4
%350 = load i8*, i8** %3
%351 = load i32, i32* %4
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i8, i8* %350, i64 %352
store i8 97, i8* %353
%354 = load i32, i32* %4
%355 = add nsw i32 %354, 1
store i32 %355, i32* %4
%356 = load i8*, i8** %3
%357 = load i32, i32* %4
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i8, i8* %356, i64 %358
store i8 95, i8* %359
%360 = load i32, i32* %4
%361 = add nsw i32 %360, 1
store i32 %361, i32* %4
%362 = load i8*, i8** %3
%363 = load i32, i32* %4
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i8, i8* %362, i64 %364
store i8 114, i8* %365
%366 = load i32, i32* %4
%367 = add nsw i32 %366, 1
store i32 %367, i32* %4
%368 = load i8*, i8** %3
%369 = load i32, i32* %4
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i8, i8* %368, i64 %370
store i8 101, i8* %371
%372 = load i32, i32* %4
%373 = add nsw i32 %372, 1
store i32 %373, i32* %4
%374 = load i8*, i8** %3
%375 = load i32, i32* %4
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i8, i8* %374, i64 %376
store i8 98, i8* %377
%378 = load i32, i32* %4
%379 = add nsw i32 %378, 1
store i32 %379, i32* %4
br label %380
380: ; preds = %331, %317
%381 = load i8*, i8** %3
%382 = load i32, i32* %4
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i8, i8* %381, i64 %383
store i8 0, i8* %384
%385 = load i32, i32* %4
%386 = icmp eq i32 %385, 0
br i1 %386, label %387, label %390
387: ; preds = %380
%388 = load i8*, i8** %3
%389 = call i32 @strcpy(i8* %388, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
br label %390
390: ; preds = %387, %380
br label %391
391: ; preds = %390, %9
%392 = load i8*, i8** %3
ret i8* %392
}

LLVM IR (-O2):
@.str = [6 x i8] c"none\00\00"
@.str.1 = [9 x i8] c"unknown\00\00"
define i8* @GetFlagStr(i32 %0) {
%2 = tail call i64 @B_TempAlloc(i32 128)
%3 = inttoptr i64 %2 to i8*
%4 = icmp eq i32 %0, 0
br i1 %4, label %5, label %7
5: ; preds = %1
%6 = tail call i32 @strcpy(i8* %3, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
br label %238
7: ; preds = %1
%8 = and i32 %0, 16
%9 = icmp eq i32 %8, 0
br i1 %9, label %11, label %10
10: ; preds = %7
store i8 106, i8* %3
br label %11
11: ; preds = %10, %7
%12 = phi i32 [ 1, %10 ], [ 0, %7 ]
%13 = and i32 %0, 32
%14 = icmp eq i32 %13, 0
br i1 %14, label %19, label %15
15: ; preds = %11
%16 = zext i32 %12 to i64
%17 = getelementptr inbounds i8, i8* %3, i64 %16
store i8 100, i8* %17
%18 = add nuw nsw i32 %12, 1
br label %19
19: ; preds = %15, %11
%20 = phi i32 [ %18, %15 ], [ %12, %11 ]
%21 = and i32 %0, 2048
%22 = icmp eq i32 %21, 0
br i1 %22, label %27, label %23
23: ; preds = %19
%24 = zext i32 %20 to i64
%25 = getelementptr inbounds i8, i8* %3, i64 %24
store i8 99, i8* %25
%26 = add nuw nsw i32 %20, 1
br label %27
27: ; preds = %23, %19
%28 = phi i32 [ %26, %23 ], [ %20, %19 ]
%29 = and i32 %0, 4096
%30 = icmp eq i32 %29, 0
br i1 %30, label %35, label %31
31: ; preds = %27
%32 = zext i32 %28 to i64
%33 = getelementptr inbounds i8, i8* %3, i64 %32
store i8 102, i8* %33
%34 = add nuw nsw i32 %28, 1
br label %35
35: ; preds = %31, %27
%36 = phi i32 [ %34, %31 ], [ %28, %27 ]
%37 = and i32 %0, 8192
%38 = icmp eq i32 %37, 0
br i1 %38, label %43, label %39
39: ; preds = %35
%40 = zext i32 %36 to i64
%41 = getelementptr inbounds i8, i8* %3, i64 %40
store i8 115, i8* %41
%42 = add nuw nsw i32 %36, 1
br label %43
43: ; preds = %39, %35
%44 = phi i32 [ %42, %39 ], [ %36, %35 ]
%45 = and i32 %0, 16384
%46 = icmp eq i32 %45, 0
br i1 %46, label %51, label %47
47: ; preds = %43
%48 = zext i32 %44 to i64
%49 = getelementptr inbounds i8, i8* %3, i64 %48
store i8 120, i8* %49
%50 = add nuw nsw i32 %44, 1
br label %51
51: ; preds = %47, %43
%52 = phi i32 [ %50, %47 ], [ %44, %43 ]
%53 = and i32 %0, 32768
%54 = icmp eq i32 %53, 0
br i1 %54, label %59, label %55
55: ; preds = %51
%56 = zext i32 %52 to i64
%57 = getelementptr inbounds i8, i8* %3, i64 %56
store i8 121, i8* %57
%58 = add nuw nsw i32 %52, 1
br label %59
59: ; preds = %55, %51
%60 = phi i32 [ %58, %55 ], [ %52, %51 ]
%61 = and i32 %0, 65536
%62 = icmp eq i32 %61, 0
br i1 %62, label %67, label %63
63: ; preds = %59
%64 = zext i32 %60 to i64
%65 = getelementptr inbounds i8, i8* %3, i64 %64
store i8 103, i8* %65
%66 = add nuw nsw i32 %60, 1
br label %67
67: ; preds = %63, %59
%68 = phi i32 [ %66, %63 ], [ %60, %59 ]
%69 = and i32 %0, 1024
%70 = icmp eq i32 %69, 0
br i1 %70, label %75, label %71
71: ; preds = %67
%72 = zext i32 %68 to i64
%73 = getelementptr inbounds i8, i8* %3, i64 %72
store i8 110, i8* %73
%74 = add nuw nsw i32 %68, 1
br label %75
75: ; preds = %71, %67
%76 = phi i32 [ %74, %71 ], [ %68, %67 ]
%77 = and i32 %0, 2097152
%78 = icmp eq i32 %77, 0
br i1 %78, label %83, label %79
79: ; preds = %75
%80 = zext i32 %76 to i64
%81 = getelementptr inbounds i8, i8* %3, i64 %80
store i8 109, i8* %81
%82 = add nuw nsw i32 %76, 1
br label %83
83: ; preds = %79, %75
%84 = phi i32 [ %82, %79 ], [ %76, %75 ]
%85 = and i32 %0, 131072
%86 = icmp eq i32 %85, 0
br i1 %86, label %119, label %87
87: ; preds = %83
%88 = icmp eq i32 %84, 0
br i1 %88, label %93, label %89
89: ; preds = %87
%90 = zext i32 %84 to i64
%91 = getelementptr inbounds i8, i8* %3, i64 %90
store i8 32, i8* %91
%92 = add nuw nsw i32 %84, 1
br label %93
93: ; preds = %89, %87
%94 = phi i32 [ %92, %89 ], [ 0, %87 ]
%95 = zext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %3, i64 %95
store i8 114, i8* %96
%97 = add nuw nsw i32 %94, 1
%98 = zext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %3, i64 %98
store i8 101, i8* %99
%100 = add nuw nsw i32 %94, 2
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %3, i64 %101
store i8 100, i8* %102
%103 = add nuw nsw i32 %94, 3
%104 = zext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %3, i64 %104
store i8 32, i8* %105
%106 = add nuw nsw i32 %94, 4
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds i8, i8* %3, i64 %107
store i8 102, i8* %108
%109 = add nuw nsw i32 %94, 5
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %3, i64 %110
store i8 108, i8* %111
%112 = add nuw nsw i32 %94, 6
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %3, i64 %113
store i8 97, i8* %114
%115 = add nuw nsw i32 %94, 7
%116 = zext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %3, i64 %116
store i8 103, i8* %117
%118 = add nuw nsw i32 %94, 8
br label %119
119: ; preds = %93, %83
%120 = phi i32 [ %118, %93 ], [ %84, %83 ]
%121 = and i32 %0, 262144
%122 = icmp eq i32 %121, 0
br i1 %122, label %158, label %123
123: ; preds = %119
%124 = icmp eq i32 %120, 0
br i1 %124, label %129, label %125
125: ; preds = %123
%126 = zext i32 %120 to i64
%127 = getelementptr inbounds i8, i8* %3, i64 %126
store i8 32, i8* %127
%128 = add nuw nsw i32 %120, 1
br label %129
129: ; preds = %125, %123
%130 = phi i32 [ %128, %125 ], [ 0, %123 ]
%131 = zext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %3, i64 %131
store i8 98, i8* %132
%133 = add nuw nsw i32 %130, 1
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %3, i64 %134
store i8 108, i8* %135
%136 = add nuw nsw i32 %130, 2
%137 = zext i32 %136 to i64
%138 = getelementptr inbounds i8, i8* %3, i64 %137
store i8 117, i8* %138
%139 = add nuw nsw i32 %130, 3
%140 = zext i32 %139 to i64
%141 = getelementptr inbounds i8, i8* %3, i64 %140
store i8 101, i8* %141
%142 = add nuw nsw i32 %130, 4
%143 = zext i32 %142 to i64
%144 = getelementptr inbounds i8, i8* %3, i64 %143
store i8 32, i8* %144
%145 = add nuw nsw i32 %130, 5
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds i8, i8* %3, i64 %146
store i8 102, i8* %147
%148 = add nuw nsw i32 %130, 6
%149 = zext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %3, i64 %149
store i8 108, i8* %150
%151 = add nuw nsw i32 %130, 7
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds i8, i8* %3, i64 %152
store i8 97, i8* %153
%154 = add nuw nsw i32 %130, 8
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %3, i64 %155
store i8 103, i8* %156
%157 = add nuw nsw i32 %130, 9
br label %158
158: ; preds = %129, %119
%159 = phi i32 [ %157, %129 ], [ %120, %119 ]
%160 = and i32 %0, 1048576
%161 = icmp eq i32 %160, 0
br i1 %161, label %194, label %162
162: ; preds = %158
%163 = icmp eq i32 %159, 0
br i1 %163, label %168, label %164
164: ; preds = %162
%165 = zext i32 %159 to i64
%166 = getelementptr inbounds i8, i8* %3, i64 %165
store i8 32, i8* %166
%167 = add nuw nsw i32 %159, 1
br label %168
168: ; preds = %164, %162
%169 = phi i32 [ %167, %164 ], [ 0, %162 ]
%170 = zext i32 %169 to i64
%171 = getelementptr inbounds i8, i8* %3, i64 %170
store i8 115, i8* %171
%172 = add nuw nsw i32 %169, 1
%173 = zext i32 %172 to i64
%174 = getelementptr inbounds i8, i8* %3, i64 %173
store i8 97, i8* %174
%175 = add nuw nsw i32 %169, 2
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %3, i64 %176
store i8 103, i8* %177
%178 = add nuw nsw i32 %169, 3
%179 = zext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %3, i64 %179
store i8 97, i8* %180
%181 = add nuw nsw i32 %169, 4
%182 = zext i32 %181 to i64
%183 = getelementptr inbounds i8, i8* %3, i64 %182
store i8 95, i8* %183
%184 = add nuw nsw i32 %169, 5
%185 = zext i32 %184 to i64
%186 = getelementptr inbounds i8, i8* %3, i64 %185
store i8 105, i8* %186
%187 = add nuw nsw i32 %169, 6
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds i8, i8* %3, i64 %188
store i8 109, i8* %189
%190 = add nuw nsw i32 %169, 7
%191 = zext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %3, i64 %191
store i8 112, i8* %192
%193 = add nuw nsw i32 %169, 8
br label %194
194: ; preds = %168, %158
%195 = phi i32 [ %193, %168 ], [ %159, %158 ]
%196 = and i32 %0, 524288
%197 = icmp eq i32 %196, 0
br i1 %197, label %232, label %198
198: ; preds = %194
%199 = icmp eq i32 %195, 0
br i1 %199, label %204, label %200
200: ; preds = %198
%201 = zext i32 %195 to i64
%202 = getelementptr inbounds i8, i8* %3, i64 %201
store i8 32, i8* %202
%203 = add nuw nsw i32 %195, 1
br label %204
204: ; preds = %198, %200
%205 = phi i32 [ %203, %200 ], [ 0, %198 ]
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %3, i64 %206
store i8 115, i8* %207
%208 = add nuw nsw i32 %205, 1
%209 = zext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %3, i64 %209
store i8 97, i8* %210
%211 = add nuw nsw i32 %205, 2
%212 = zext i32 %211 to i64
%213 = getelementptr inbounds i8, i8* %3, i64 %212
store i8 103, i8* %213
%214 = add nuw nsw i32 %205, 3
%215 = zext i32 %214 to i64
%216 = getelementptr inbounds i8, i8* %3, i64 %215
store i8 97, i8* %216
%217 = add nuw nsw i32 %205, 4
%218 = zext i32 %217 to i64
%219 = getelementptr inbounds i8, i8* %3, i64 %218
store i8 95, i8* %219
%220 = add nuw nsw i32 %205, 5
%221 = zext i32 %220 to i64
%222 = getelementptr inbounds i8, i8* %3, i64 %221
store i8 114, i8* %222
%223 = add nuw nsw i32 %205, 6
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %3, i64 %224
store i8 101, i8* %225
%226 = add nuw nsw i32 %205, 7
%227 = zext i32 %226 to i64
%228 = getelementptr inbounds i8, i8* %3, i64 %227
store i8 98, i8* %228
%229 = add nuw nsw i32 %205, 8
%230 = zext i32 %229 to i64
%231 = getelementptr inbounds i8, i8* %3, i64 %230
store i8 0, i8* %231
br label %238
232: ; preds = %194
%233 = zext i32 %195 to i64
%234 = getelementptr inbounds i8, i8* %3, i64 %233
store i8 0, i8* %234
%235 = icmp eq i32 %195, 0
br i1 %235, label %236, label %238
236: ; preds = %232
%237 = tail call i32 @strcpy(i8* %3, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0))
br label %238
238: ; preds = %204, %232, %236, %5
ret i8* %3
}