#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 */
int /*<<< orphan*/ namegen_cap(int, int);
char *namegen_copy(char *, char *, int, unsigned long *, int);
int namegen_rand32(unsigned long *);
int namegen(char *dst, unsigned long len, const char *pattern,
            unsigned long *seed) {
  int depth = 0;
  char *p = dst;
  char *e = dst + len;
  int capitalize = 0;
  char *reset[32];
  unsigned long n[32];
  unsigned long silent = 0;
  unsigned long literal = 0;
  unsigned long capstack = 0;
  n[0] = 1;
  reset[0] = dst;
  for (; *pattern; pattern++) {
    unsigned long bit;
    int c = *pattern;
    switch (c) {
    case '<':
      if (++depth == 32) {
        *dst = 0;
        return 3;
      }
      bit = 1UL << depth;
      n[depth] = 1;
      reset[depth] = p;
      literal &= ~bit;
      silent &= ~bit;
      silent |= (silent << 1) & bit;
      capstack &= ~bit;
      capstack |= (unsigned long)capitalize << depth;
      break;
    case '(':
      if (++depth == 32) {
        *dst = 0;
        return 3;
      }
      bit = 1UL << depth;
      n[depth] = 1;
      reset[depth] = p;
      literal |= bit;
      silent &= ~bit;
      silent |= (silent << 1) & bit;
      capstack &= ~bit;
      capstack |= (unsigned long)capitalize << depth;
      break;
    case '>':
      if (depth == 0) {
        *dst = 0;
        return 2;
      }
      bit = 1UL << depth--;
      if (literal & bit) {
        *dst = 0;
        return 2;
      }
      break;
    case ')':
      if (depth == 0) {
        *dst = 0;
        return 2;
      }
      bit = 1UL << depth--;
      if (!(literal & bit)) {
        *dst = 0;
        return 2;
      }
      break;
    case '|':
      bit = 1UL << depth;
      if (!(silent & (bit >> 1))) {
        if (namegen_rand32(seed) < 0xffffffffUL / ++n[depth]) {
          p = reset[depth];
          silent &= ~bit;
          capitalize = !!(capstack & bit);
        } else {
          silent |= bit;
        }
      }
      break;
    case '!':
      capitalize = 1;
      break;
    default:
      bit = 1UL << depth;
      if (!(silent & bit)) {
        if (literal & bit) {
          if (p != e)
            *p++ = namegen_cap(c, capitalize);
        } else {
          p = namegen_copy(p, e, c, seed, capitalize);
        }
      }
      capitalize = 0;
    }
  }
  if (depth) {
    *dst = 0;
    return 2;
  } else if (p == e) {
    p[-1] = 0;
    return 1;
  } else {
    *p = 0;
    return 0;
  }
}


x86 assembly (clang, -O0):
<namegen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movq   $0x0,-0x258(%rbp)
movq   $0x0,-0x260(%rbp)
movq   $0x0,-0x268(%rbp)
movq   $0x1,-0x250(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     167d <namegen+0x54d>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x274(%rbp)
mov    -0x274(%rbp),%eax
mov    %eax,-0x278(%rbp)
sub    $0x21,%eax
je     15b8 <namegen+0x488>
jmp    11d8 <namegen+0xa8>
mov    -0x278(%rbp),%eax
sub    $0x28,%eax
je     131d <namegen+0x1ed>
jmp    11ec <namegen+0xbc>
mov    -0x278(%rbp),%eax
sub    $0x29,%eax
je     1465 <namegen+0x335>
jmp    1200 <namegen+0xd0>
mov    -0x278(%rbp),%eax
sub    $0x3c,%eax
je     123c <namegen+0x10c>
jmp    1214 <namegen+0xe4>
mov    -0x278(%rbp),%eax
sub    $0x3e,%eax
je     13fa <namegen+0x2ca>
jmp    1228 <namegen+0xf8>
mov    -0x278(%rbp),%eax
sub    $0x7c,%eax
je     14d0 <namegen+0x3a0>
jmp    15c4 <namegen+0x494>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x20,%eax
jne    1261 <namegen+0x131>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x3,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
movslq -0x2c(%rbp),%rax
movq   $0x1,-0x250(%rbp,%rax,8)
mov    -0x38(%rbp),%rcx
movslq -0x2c(%rbp),%rax
mov    %rcx,-0x150(%rbp,%rax,8)
ff
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x260(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x258(%rbp),%rax
shl    $0x1,%rax
and    -0x270(%rbp),%rax
or     -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x268(%rbp),%rax
mov    %rax,-0x268(%rbp)
movslq -0x44(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    %cl,%rax
or     -0x268(%rbp),%rax
mov    %rax,-0x268(%rbp)
jmp    1667 <namegen+0x537>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x20,%eax
jne    1342 <namegen+0x212>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x3,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
movslq -0x2c(%rbp),%rax
movq   $0x1,-0x250(%rbp,%rax,8)
mov    -0x38(%rbp),%rcx
movslq -0x2c(%rbp),%rax
mov    %rcx,-0x150(%rbp,%rax,8)
ff
mov    -0x270(%rbp),%rax
or     -0x260(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x258(%rbp),%rax
shl    $0x1,%rax
and    -0x270(%rbp),%rax
or     -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x268(%rbp),%rax
mov    %rax,-0x268(%rbp)
movslq -0x44(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    %cl,%rax
or     -0x268(%rbp),%rax
mov    %rax,-0x268(%rbp)
jmp    1667 <namegen+0x537>
cmpl   $0x0,-0x2c(%rbp)
jne    1417 <namegen+0x2e7>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x2,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
mov    -0x260(%rbp),%rax
and    -0x270(%rbp),%rax
cmp    $0x0,%rax
je     1460 <namegen+0x330>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x2,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
jmp    1667 <namegen+0x537>
cmpl   $0x0,-0x2c(%rbp)
jne    1482 <namegen+0x352>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x2,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x2c(%rbp)
mov    %eax,%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
mov    -0x260(%rbp),%rax
and    -0x270(%rbp),%rax
cmp    $0x0,%rax
jne    14cb <namegen+0x39b>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x2,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
jmp    1667 <namegen+0x537>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
mov    -0x258(%rbp),%rax
mov    -0x270(%rbp),%rcx
shr    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    15b3 <namegen+0x483>
mov    -0x28(%rbp),%rdi
call   1040 <namegen_rand32@plt>
cltq
mov    %rax,-0x280(%rbp)
movslq -0x2c(%rbp),%rax
mov    -0x250(%rbp,%rax,8),%rcx
ff
add    $0x1,%rcx
mov    %rcx,-0x250(%rbp,%rax,8)
ff
mov    $0xffffffff,%eax
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x280(%rbp),%rax
cmp    %rcx,%rax
jae    1599 <namegen+0x469>
movslq -0x2c(%rbp),%rax
mov    -0x150(%rbp,%rax,8),%rax
ff
mov    %rax,-0x38(%rbp)
mov    -0x270(%rbp),%rax
xor    $0xffffffffffffffff,%rax
and    -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
mov    -0x268(%rbp),%rax
and    -0x270(%rbp),%rax
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
jmp    15ae <namegen+0x47e>
mov    -0x270(%rbp),%rax
or     -0x258(%rbp),%rax
mov    %rax,-0x258(%rbp)
jmp    15b3 <namegen+0x483>
jmp    1667 <namegen+0x537>
movl   $0x1,-0x44(%rbp)
jmp    1667 <namegen+0x537>
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,-0x270(%rbp)
mov    -0x258(%rbp),%rax
and    -0x270(%rbp),%rax
cmp    $0x0,%rax
jne    1660 <namegen+0x530>
mov    -0x260(%rbp),%rax
and    -0x270(%rbp),%rax
cmp    $0x0,%rax
je     163c <namegen+0x50c>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
je     1637 <namegen+0x507>
mov    -0x274(%rbp),%edi
mov    -0x44(%rbp),%esi
call   1030 <namegen_cap@plt>
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    165b <namegen+0x52b>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x274(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x44(%rbp),%r8d
call   1050 <namegen_copy@plt>
mov    %rax,-0x38(%rbp)
jmp    1660 <namegen+0x530>
movl   $0x0,-0x44(%rbp)
jmp    166c <namegen+0x53c>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11a4 <namegen+0x74>
cmpl   $0x0,-0x2c(%rbp)
je     169a <namegen+0x56a>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x2,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jne    16bc <namegen+0x58c>
mov    -0x38(%rbp),%rax
movb   $0x0,-0x1(%rax)
movl   $0x1,-0x4(%rbp)
jmp    16ca <namegen+0x59a>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<namegen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %rcx,0x28(%rsp)
add    %rdi,%rsi
movq   $0x1,0x30(%rsp)
mov    %rdi,0x130(%rsp)
mov    (%rdx),%al
test   %al,%al
je     13d2 <namegen+0x2a2>
mov    %rdx,%rbx
add    $0x1,%rbx
xor    %r8d,%r8d
lea    0xe8b(%rip),%r9
xor    %r10d,%r10d
xor    %r12d,%r12d
xor    %r13d,%r13d
mov    %rdi,0x8(%rsp)
xor    %ebp,%ebp
mov    %rsi,0x10(%rsp)
jmp    11ec <namegen+0xbc>
add    $0x1,%ebp
cmp    $0x20,%ebp
je     13eb <namegen+0x2bb>
mov    $0x1,%eax
mov    %ebp,%ecx
shl    %cl,%rax
movslq %ebp,%rcx
movq   $0x1,0x30(%rsp,%rcx,8)
mov    %rdi,0x130(%rsp,%rcx,8)
btr    %rbp,%r10
btr    %rbp,%r12
lea    (%r12,%r12,1),%rcx
and    %rax,%rcx
or     %rcx,%r12
btr    %rbp,%r8
mov    %r13d,%eax
mov    %ebp,%ecx
shl    %cl,%rax
or     %rax,%r8
mov    %r13d,%r15d
movzbl (%rbx),%eax
add    $0x1,%rbx
mov    %r15d,%r13d
test   %al,%al
je     13c4 <namegen+0x294>
movsbl %al,%edx
lea    -0x21(%rdx),%eax
cmp    $0x1d,%eax
ja     1240 <namegen+0x110>
mov    $0x1,%r15d
movslq (%r9,%rax,4),%rax
add    %r9,%rax
jmp    *%rax
add    $0x1,%ebp
cmp    $0x20,%ebp
je     13eb <namegen+0x2bb>
mov    $0x1,%eax
mov    %ebp,%ecx
shl    %cl,%rax
movslq %ebp,%rcx
movq   $0x1,0x30(%rsp,%rcx,8)
mov    %rdi,0x130(%rsp,%rcx,8)
bts    %rbp,%r10
jmp    11ba <namegen+0x8a>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x7c,%edx
jne    12a4 <namegen+0x174>
mov    $0x1,%r14d
mov    %ebp,%ecx
shl    %cl,%r14
mov    %r14,%rax
shr    %rax
test   %rax,%r12
jne    11d7 <namegen+0xa7>
mov    %r10,0x20(%rsp)
mov    %rdi,0x18(%rsp)
mov    %r8,%r15
mov    0x28(%rsp),%rdi
call   1040 <namegen_rand32@plt>
mov    %eax,%ecx
movslq %ebp,%rsi
mov    0x30(%rsp,%rsi,8),%rdi
add    $0x1,%rdi
mov    %rdi,0x30(%rsp,%rsi,8)
mov    %rdi,%rax
shr    $0x20,%rax
jne    1369 <namegen+0x239>
mov    $0xffffffff,%eax
xor    %edx,%edx
div    %edi
jmp    136b <namegen+0x23b>
mov    $0x1,%eax
mov    %ebp,%ecx
shl    %cl,%rax
xor    %r15d,%r15d
bt     %rbp,%r12
jb     11da <namegen+0xaa>
test   %rax,%r10
je     1337 <namegen+0x207>
cmp    %rsi,%rdi
je     13bc <namegen+0x28c>
mov    %rdi,0x18(%rsp)
mov    %edx,%edi
mov    %r13d,%esi
mov    %r8,%r14
mov    %r10,%r13
call   1030 <namegen_cap@plt>
mov    %r13,%r10
mov    0x18(%rsp),%rdi
lea    0xd13(%rip),%r9
mov    %r14,%r8
mov    0x10(%rsp),%rsi
mov    %al,(%rdi)
add    $0x1,%rdi
jmp    11da <namegen+0xaa>
mov    $0x2,%eax
test   %ebp,%ebp
je     13e4 <namegen+0x2b4>
bt     %rbp,%r10
jb     132f <namegen+0x1ff>
jmp    13e4 <namegen+0x2b4>
mov    $0x2,%eax
test   %ebp,%ebp
je     13e4 <namegen+0x2b4>
bt     %rbp,%r10
jb     13e4 <namegen+0x2b4>
add    $0xffffffff,%ebp
jmp    11d7 <namegen+0xa7>
mov    0x10(%rsp),%rsi
mov    0x28(%rsp),%rcx
mov    %r8,%r14
mov    %r13d,%r8d
mov    %r10,%r13
call   1050 <namegen_copy@plt>
mov    %r13,%r10
lea    0xca7(%rip),%r9
mov    %r14,%r8
mov    0x10(%rsp),%rsi
mov    %rax,%rdi
jmp    11da <namegen+0xaa>
xor    %eax,%eax
mov    %r15,%r8
lea    0xc8b(%rip),%r9
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r10
movslq %ecx,%rcx
cmp    %rcx,%rax
jbe    13ac <namegen+0x27c>
mov    0x130(%rsp,%rsi,8),%rdi
mov    %r14,%rax
not    %rax
and    %rax,%r12
xor    %r15d,%r15d
test   %r14,%r8
setne  %r15b
mov    0x10(%rsp),%rsi
jmp    11da <namegen+0xaa>
or     %r14,%r12
mov    %r13d,%r15d
mov    0x10(%rsp),%rsi
jmp    11da <namegen+0xaa>
mov    %rsi,%rdi
jmp    11da <namegen+0xaa>
mov    $0x2,%eax
test   %ebp,%ebp
mov    0x8(%rsp),%rcx
jne    13f5 <namegen+0x2c5>
lea    -0x1(%rsi),%rcx
xor    %eax,%eax
cmp    %rsi,%rdi
sete   %al
cmovne %rdi,%rcx
jmp    13f5 <namegen+0x2c5>
mov    0x8(%rsp),%rcx
jmp    13f5 <namegen+0x2c5>
mov    $0x3,%eax
mov    0x8(%rsp),%rcx
movb   $0x0,(%rcx)
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @namegen(i8* %0, i64 %1, i8* nocapture %2, i64* %3) {
%5 = alloca [32 x i8*]
%6 = alloca [32 x i64]
%7 = getelementptr inbounds i8, i8* %0, i64 %1
%8 = bitcast [32 x i8*]* %5 to i8*
%9 = bitcast [32 x i64]* %6 to i8*
%10 = getelementptr inbounds [32 x i64], [32 x i64]* %6, i64 0, i64 0
store i64 1, i64* %10
%11 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 0
store i8* %0, i8** %11
%12 = load i8, i8* %2
%13 = icmp eq i8 %12, 0
br i1 %13, label %131, label %14
14: ; preds = %4, %119
%15 = phi i8 [ %127, %119 ], [ %12, %4 ]
%16 = phi i64 [ %125, %119 ], [ 0, %4 ]
%17 = phi i64 [ %124, %119 ], [ 0, %4 ]
%18 = phi i64 [ %123, %119 ], [ 0, %4 ]
%19 = phi i32 [ %122, %119 ], [ 0, %4 ]
%20 = phi i8* [ %126, %119 ], [ %2, %4 ]
%21 = phi i8* [ %121, %119 ], [ %0, %4 ]
%22 = phi i32 [ %120, %119 ], [ 0, %4 ]
%23 = sext i8 %15 to i32
switch i32 %23, label %103 [
i32 60, label %24
i32 40, label %43
i32 62, label %62
i32 41, label %70
i32 124, label %78
i32 33, label %119
]
24: ; preds = %14
%25 = add nsw i32 %22, 1
%26 = icmp eq i32 %25, 32
br i1 %26, label %137, label %27
27: ; preds = %24
%28 = zext i32 %25 to i64
%29 = shl nuw i64 1, %28
%30 = sext i32 %25 to i64
%31 = getelementptr inbounds [32 x i64], [32 x i64]* %6, i64 0, i64 %30
store i64 1, i64* %31
%32 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 %30
store i8* %21, i8** %32
%33 = xor i64 %29, -1
%34 = and i64 %17, %33
%35 = and i64 %18, %33
%36 = shl i64 %35, 1
%37 = and i64 %36, %29
%38 = or i64 %37, %35
%39 = and i64 %16, %33
%40 = zext i32 %19 to i64
%41 = shl i64 %40, %28
%42 = or i64 %39, %41
br label %119
43: ; preds = %14
%44 = add nsw i32 %22, 1
%45 = icmp eq i32 %44, 32
br i1 %45, label %137, label %46
46: ; preds = %43
%47 = zext i32 %44 to i64
%48 = shl nuw i64 1, %47
%49 = sext i32 %44 to i64
%50 = getelementptr inbounds [32 x i64], [32 x i64]* %6, i64 0, i64 %49
store i64 1, i64* %50
%51 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 %49
store i8* %21, i8** %51
%52 = or i64 %17, %48
%53 = xor i64 %48, -1
%54 = and i64 %18, %53
%55 = shl i64 %54, 1
%56 = and i64 %55, %48
%57 = or i64 %56, %54
%58 = and i64 %16, %53
%59 = zext i32 %19 to i64
%60 = shl i64 %59, %47
%61 = or i64 %58, %60
br label %119
62: ; preds = %14
%63 = icmp eq i32 %22, 0
br i1 %63, label %137, label %64
64: ; preds = %62
%65 = add nsw i32 %22, -1
%66 = zext i32 %22 to i64
%67 = shl nuw i64 1, %66
%68 = and i64 %17, %67
%69 = icmp eq i64 %68, 0
br i1 %69, label %119, label %137
70: ; preds = %14
%71 = icmp eq i32 %22, 0
br i1 %71, label %137, label %72
72: ; preds = %70
%73 = add nsw i32 %22, -1
%74 = zext i32 %22 to i64
%75 = shl nuw i64 1, %74
%76 = and i64 %17, %75
%77 = icmp eq i64 %76, 0
br i1 %77, label %137, label %119
78: ; preds = %14
%79 = zext i32 %22 to i64
%80 = shl nuw i64 1, %79
%81 = lshr i64 %80, 1
%82 = and i64 %18, %81
%83 = icmp eq i64 %82, 0
br i1 %83, label %84, label %119
84: ; preds = %78
%85 = tail call i32 @namegen_rand32(i64* %3)
%86 = sext i32 %85 to i64
%87 = sext i32 %22 to i64
%88 = getelementptr inbounds [32 x i64], [32 x i64]* %6, i64 0, i64 %87
%89 = load i64, i64* %88
%90 = add i64 %89, 1
store i64 %90, i64* %88
%91 = udiv i64 4294967295, %90
%92 = icmp ugt i64 %91, %86
br i1 %92, label %93, label %101
93: ; preds = %84
%94 = getelementptr inbounds [32 x i8*], [32 x i8*]* %5, i64 0, i64 %87
%95 = load i8*, i8** %94
%96 = xor i64 %80, -1
%97 = and i64 %18, %96
%98 = and i64 %16, %80
%99 = icmp ne i64 %98, 0
%100 = zext i1 %99 to i32
br label %119
101: ; preds = %84
%102 = or i64 %18, %80
br label %119
103: ; preds = %14
%104 = zext i32 %22 to i64
%105 = shl nuw i64 1, %104
%106 = and i64 %18, %105
%107 = icmp eq i64 %106, 0
br i1 %107, label %108, label %119
108: ; preds = %103
%109 = and i64 %17, %105
%110 = icmp eq i64 %109, 0
br i1 %110, label %117, label %111
111: ; preds = %108
%112 = icmp eq i8* %21, %7
br i1 %112, label %119, label %113
113: ; preds = %111
%114 = tail call i32 @namegen_cap(i32 %23, i32 %19)
%115 = trunc i32 %114 to i8
%116 = getelementptr inbounds i8, i8* %21, i64 1
store i8 %115, i8* %21
br label %119
117: ; preds = %108
%118 = tail call i8* @namegen_copy(i8* %21, i8* %7, i32 %23, i64* %3, i32 %19)
br label %119
119: ; preds = %103, %111, %113, %117, %14, %78, %101, %93, %72, %64, %46, %27
%120 = phi i32 [ %22, %103 ], [ %22, %111 ], [ %22, %113 ], [ %22, %117 ], [ %22, %14 ], [ %25, %27 ], [ %44, %46 ], [ %65, %64 ], [ %73, %72 ], [ %22, %101 ], [ %22, %93 ], [ %22, %78 ]
%121 = phi i8* [ %21, %103 ], [ %7, %111 ], [ %116, %113 ], [ %118, %117 ], [ %21, %14 ], [ %21, %27 ], [ %21, %46 ], [ %21, %64 ], [ %21, %72 ], [ %21, %101 ], [ %95, %93 ], [ %21, %78 ]
%122 = phi i32 [ 0, %103 ], [ 0, %111 ], [ 0, %113 ], [ 0, %117 ], [ 1, %14 ], [ %19, %27 ], [ %19, %46 ], [ %19, %64 ], [ %19, %72 ], [ %19, %101 ], [ %100, %93 ], [ %19, %78 ]
%123 = phi i64 [ %18, %103 ], [ %18, %111 ], [ %18, %113 ], [ %18, %117 ], [ %18, %14 ], [ %38, %27 ], [ %57, %46 ], [ %18, %64 ], [ %18, %72 ], [ %102, %101 ], [ %97, %93 ], [ %18, %78 ]
%124 = phi i64 [ %17, %103 ], [ %17, %111 ], [ %17, %113 ], [ %17, %117 ], [ %17, %14 ], [ %34, %27 ], [ %52, %46 ], [ %17, %64 ], [ %17, %72 ], [ %17, %101 ], [ %17, %93 ], [ %17, %78 ]
%125 = phi i64 [ %16, %103 ], [ %16, %111 ], [ %16, %113 ], [ %16, %117 ], [ %16, %14 ], [ %42, %27 ], [ %61, %46 ], [ %16, %64 ], [ %16, %72 ], [ %16, %101 ], [ %16, %93 ], [ %16, %78 ]
%126 = getelementptr inbounds i8, i8* %20, i64 1
%127 = load i8, i8* %126
%128 = icmp eq i8 %127, 0
br i1 %128, label %129, label %14
129: ; preds = %119
%130 = icmp eq i32 %120, 0
br i1 %130, label %131, label %137
131: ; preds = %4, %129
%132 = phi i8* [ %121, %129 ], [ %0, %4 ]
%133 = icmp eq i8* %132, %7
%134 = getelementptr inbounds i8, i8* %7, i64 -1
%135 = select i1 %133, i8* %134, i8* %132
%136 = zext i1 %133 to i32
br label %137
137: ; preds = %72, %70, %64, %62, %43, %24, %131, %129
%138 = phi i8* [ %0, %129 ], [ %135, %131 ], [ %0, %24 ], [ %0, %43 ], [ %0, %62 ], [ %0, %64 ], [ %0, %70 ], [ %0, %72 ]
%139 = phi i32 [ 2, %129 ], [ %136, %131 ], [ 2, %72 ], [ 2, %70 ], [ 2, %64 ], [ 2, %62 ], [ 3, %43 ], [ 3, %24 ]
store i8 0, i8* %138
ret i32 %139
}