char *CapGoto(CM, destcol, destline)
char *CM;
{
  register char *cp, *dp;
  register c, which, oncol;
  static char result[64];
  cp = CM;
  if (!cp)
  toohard:
    return ("bad capgoto");
  dp = result;
  oncol = 0;
  which = destline;
  while (c = *cp++) {
    if (c != '%') {
      *dp++ = c;
      continue;
    }
    switch (c = *cp++) {
    case 'n':
      destcol ^= 0140;
      destline ^= 0140;
      goto setwhich;
    case 'd':
      if (which < 10)
        goto one;
      if (which < 100)
        goto two;
    case '3':
      *dp++ = (which / 100) | '0';
      which %= 100;
    case '2':
    two:
      *dp++ = which / 10 | '0';
    one:
      *dp++ = which % 10 | '0';
    swap:
      oncol = 1 - oncol;
    setwhich:
      which = oncol ? destcol : destline;
      continue;
    case '>':
      if (which > *cp++)
        which += *cp++;
      else
        cp++;
      continue;
    case '+':
      which += *cp++;
    case '.':
      *dp++ = which;
      goto swap;
    case 'r':
      oncol = 1;
      goto setwhich;
    case 'i':
      destcol++;
      destline++;
      which++;
      continue;
    case '%':
      *dp++ = c;
      continue;
    case '/':
      c = *cp;
      *dp++ = which / c | '0';
      which %= *cp++;
      continue;
    case 'B':
      which = (which / 10 << 4) + which % 10;
      continue;
    case 'D':
      which = which - 2 * (which % 16);
      continue;
    case 'p':
    case 'P':
    case '\'':
    case '{':
    case '?':
      tparm(dp, cp - 2, destline, destcol);
      return (result);
    default:
      goto toohard;
    }
  }
  *dp = 0;
  return (result);
}


x86 assembly (clang, -O0):
<CapGoto>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    114a <CapGoto+0x3a>
jmp    113a <CapGoto+0x2a>
lea    0x101b(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1457 <CapGoto+0x347>
lea    0x2eef(%rip),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
je     1445 <CapGoto+0x335>
cmpl   $0x25,-0x2c(%rbp)
je     11a5 <CapGoto+0x95>
mov    -0x2c(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1162 <CapGoto+0x52>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
add    $0xffffffdb,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x56,%eax
ja     1440 <CapGoto+0x330>
mov    -0x40(%rbp),%rax
lea    0xe29(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x14(%rbp),%eax
xor    $0x60,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
xor    $0x60,%eax
mov    %eax,-0x18(%rbp)
jmp    129b <CapGoto+0x18b>
cmpl   $0xa,-0x30(%rbp)
jge    1206 <CapGoto+0xf6>
jmp    126f <CapGoto+0x15f>
cmpl   $0x64,-0x30(%rbp)
jge    1215 <CapGoto+0x105>
jmp    124e <CapGoto+0x13e>
jmp    121a <CapGoto+0x10a>
mov    -0x30(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
or     $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
mov    $0x64,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
jmp    124e <CapGoto+0x13e>
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
or     $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
or     $0x30,%edx
mov    %dl,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    $0x1,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     12b0 <CapGoto+0x1a0>
mov    -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12b6 <CapGoto+0x1a6>
mov    -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jle    12fb <CapGoto+0x1eb>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1307 <CapGoto+0x1f7>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1290 <CapGoto+0x180>
movl   $0x1,-0x34(%rbp)
jmp    129b <CapGoto+0x18b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x2c(%rbp),%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1162 <CapGoto+0x52>
mov    -0x20(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
cltd
idivl  -0x2c(%rbp)
or     $0x30,%eax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%ecx
mov    -0x30(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
shl    $0x4,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x48(%rbp),%eax
add    %edx,%eax
mov    %eax,-0x30(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    -0x4c(%rbp),%eax
shl    $0x1,%edx
sub    %edx,%eax
mov    %eax,-0x30(%rbp)
jmp    1162 <CapGoto+0x52>
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%rsi
add    $0xfffffffffffffffe,%rsi
mov    -0x18(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    $0x0,%al
call   1030 <tparm@plt>
lea    0x2c09(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1457 <CapGoto+0x347>
jmp    113a <CapGoto+0x2a>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
lea    0x2bed(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CapGoto>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
lea    0x103e(%rip),%r9
test   %rdi,%rdi
je     1308 <CapGoto+0x1f8>
mov    %edx,%r8d
mov    %esi,%r10d
mov    %rdi,%r15
xor    %ebp,%ebp
lea    0x2f07(%rip),%rdi
lea    0xec0(%rip),%r11
jmp    1158 <CapGoto+0x48>
add    $0x4,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%r15
mov    %ecx,%edx
mov    %r14d,%ebp
mov    %ebp,%r14d
mov    %edx,%ecx
mov    %r15,%rsi
movzbl (%r15),%eax
cmp    $0x25,%al
je     1180 <CapGoto+0x70>
test   %al,%al
je     12ef <CapGoto+0x1df>
add    $0x1,%rsi
mov    %al,(%rdi)
add    $0x1,%rdi
jmp    1150 <CapGoto+0x40>
nopl   0x0(%rax)
movsbl 0x1(%rsi),%ebx
lea    -0x25(%rbx),%edx
cmp    $0x56,%edx
ja     1308 <CapGoto+0x1f8>
lea    0x2(%rsi),%r15
mov    $0x1,%ebp
movslq (%r11,%rdx,4),%rax
add    %r11,%rax
mov    %r10d,%edx
jmp    *%rax
mov    %bl,(%rdi)
add    $0x1,%rdi
jmp    1153 <CapGoto+0x43>
movzbl 0x2(%rsi),%eax
add    $0x3,%rsi
add    %eax,%ecx
mov    %rsi,%r15
mov    %cl,(%rdi)
jmp    12b4 <CapGoto+0x1a4>
movsbl 0x2(%rsi),%ebx
mov    %ecx,%eax
cltd
idiv   %ebx
or     $0x30,%al
mov    %al,(%rdi)
add    $0x1,%rdi
movsbl 0x2(%rsi),%ebx
add    $0x3,%rsi
mov    %ecx,%eax
cltd
idiv   %ebx
mov    %rsi,%r15
mov    %r14d,%ebp
jmp    1158 <CapGoto+0x48>
movsbl (%r15),%eax
cmp    %eax,%ecx
jle    1142 <CapGoto+0x32>
movsbl 0x3(%rsi),%eax
add    %eax,%ecx
jmp    1142 <CapGoto+0x32>
movslq %ecx,%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rax
add    %edx,%eax
mov    %eax,%edx
shl    $0x4,%edx
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%ecx
add    %edx,%ecx
jmp    1153 <CapGoto+0x43>
lea    0xf(%rcx),%eax
test   %ecx,%ecx
cmovns %ecx,%eax
and    $0x7ffffff0,%eax
mov    %ecx,%edx
sub    %eax,%edx
add    %edx,%edx
sub    %edx,%ecx
jmp    1153 <CapGoto+0x43>
cmp    $0xa,%ecx
jl     1292 <CapGoto+0x182>
cmp    $0x64,%ecx
jb     1273 <CapGoto+0x163>
movslq %ecx,%rax
imul   $0x51eb851f,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
sar    $0x25,%rax
add    %edx,%eax
imul   $0x64,%eax,%edx
or     $0x30,%al
mov    %al,(%rdi)
add    $0x1,%rdi
sub    %edx,%ecx
movslq %ecx,%rax
imul   $0x66666667,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rax
add    %edx,%eax
or     $0x30,%al
mov    %al,(%rdi)
add    $0x1,%rdi
movslq %ecx,%rax
imul   $0x66666667,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x22,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%eax
or     $0x30,%al
mov    %al,(%rdi)
add    $0x1,%rdi
mov    $0x1,%eax
sub    %r14d,%eax
mov    %eax,%r14d
test   %r14d,%r14d
mov    %r10d,%edx
cmove  %r8d,%edx
mov    %r14d,%ebp
jmp    1158 <CapGoto+0x48>
add    $0x1,%r10d
add    $0x1,%r8d
add    $0x1,%ecx
jmp    1153 <CapGoto+0x43>
xor    $0x60,%r10d
xor    $0x60,%r8d
jmp    12c3 <CapGoto+0x1b3>
movb   $0x0,(%rdi)
jmp    1301 <CapGoto+0x1f1>
mov    %r8d,%edx
mov    %r10d,%ecx
xor    %eax,%eax
call   1030 <tparm@plt>
lea    0x2d38(%rip),%r9
mov    %r9,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@CapGoto.result = internal global [64 x i8] zeroinitializer
@.str = [12 x i8] c"bad capgoto\00"
define i8* @CapGoto(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
%13 = load i8*, i8** %5
store i8* %13, i8** %8
%14 = load i8*, i8** %8
%15 = icmp ne i8* %14, null
br i1 %15, label %18, label %16
16: ; preds = %3
br label %17
17: ; preds = %169, %16
store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), i8** %4
br label %172
18: ; preds = %3
store i8* getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), i8** %9
store i32 0, i32* %12
%19 = load i32, i32* %7
store i32 %19, i32* %11
br label %20
20: ; preds = %156, %149, %132, %127, %120, %106, %87, %29, %18
%21 = load i8*, i8** %8
%22 = getelementptr inbounds i8, i8* %21, i32 1
store i8* %22, i8** %8
%23 = load i8, i8* %21
%24 = sext i8 %23 to i32
store i32 %24, i32* %10
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %170
26: ; preds = %20
%27 = load i32, i32* %10
%28 = icmp ne i32 %27, 37
br i1 %28, label %29, label %34
29: ; preds = %26
%30 = load i32, i32* %10
%31 = trunc i32 %30 to i8
%32 = load i8*, i8** %9
%33 = getelementptr inbounds i8, i8* %32, i32 1
store i8* %33, i8** %9
store i8 %31, i8* %32
br label %20
34: ; preds = %26
%35 = load i8*, i8** %8
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %8
%37 = load i8, i8* %35
%38 = sext i8 %37 to i32
store i32 %38, i32* %10
switch i32 %38, label %169 [
i32 110, label %39
i32 100, label %44
i32 51, label %53
i32 50, label %62
i32 62, label %89
i32 43, label %107
i32 46, label %114
i32 114, label %119
i32 105, label %120
i32 37, label %127
i32 47, label %132
i32 66, label %149
i32 68, label %156
i32 112, label %162
i32 80, label %162
i32 39, label %162
i32 123, label %162
i32 63, label %162
]
39: ; preds = %34
%40 = load i32, i32* %6
%41 = xor i32 %40, 96
store i32 %41, i32* %6
%42 = load i32, i32* %7
%43 = xor i32 %42, 96
store i32 %43, i32* %7
br label %80
44: ; preds = %34
%45 = load i32, i32* %11
%46 = icmp slt i32 %45, 10
br i1 %46, label %47, label %48
47: ; preds = %44
br label %70
48: ; preds = %44
%49 = load i32, i32* %11
%50 = icmp slt i32 %49, 100
br i1 %50, label %51, label %52
51: ; preds = %48
br label %63
52: ; preds = %48
br label %53
53: ; preds = %34, %52
%54 = load i32, i32* %11
%55 = sdiv i32 %54, 100
%56 = or i32 %55, 48
%57 = trunc i32 %56 to i8
%58 = load i8*, i8** %9
%59 = getelementptr inbounds i8, i8* %58, i32 1
store i8* %59, i8** %9
store i8 %57, i8* %58
%60 = load i32, i32* %11
%61 = srem i32 %60, 100
store i32 %61, i32* %11
br label %62
62: ; preds = %34, %53
br label %63
63: ; preds = %62, %51
%64 = load i32, i32* %11
%65 = sdiv i32 %64, 10
%66 = or i32 %65, 48
%67 = trunc i32 %66 to i8
%68 = load i8*, i8** %9
%69 = getelementptr inbounds i8, i8* %68, i32 1
store i8* %69, i8** %9
store i8 %67, i8* %68
br label %70
70: ; preds = %63, %47
%71 = load i32, i32* %11
%72 = srem i32 %71, 10
%73 = or i32 %72, 48
%74 = trunc i32 %73 to i8
%75 = load i8*, i8** %9
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %9
store i8 %74, i8* %75
br label %77
77: ; preds = %114, %70
%78 = load i32, i32* %12
%79 = sub nsw i32 1, %78
store i32 %79, i32* %12
br label %80
80: ; preds = %119, %77, %39
%81 = load i32, i32* %12
%82 = icmp ne i32 %81, 0
br i1 %82, label %83, label %85
83: ; preds = %80
%84 = load i32, i32* %6
br label %87
85: ; preds = %80
%86 = load i32, i32* %7
br label %87
87: ; preds = %85, %83
%88 = phi i32 [ %84, %83 ], [ %86, %85 ]
store i32 %88, i32* %11
br label %20
89: ; preds = %34
%90 = load i32, i32* %11
%91 = load i8*, i8** %8
%92 = getelementptr inbounds i8, i8* %91, i32 1
store i8* %92, i8** %8
%93 = load i8, i8* %91
%94 = sext i8 %93 to i32
%95 = icmp sgt i32 %90, %94
br i1 %95, label %96, label %103
96: ; preds = %89
%97 = load i8*, i8** %8
%98 = getelementptr inbounds i8, i8* %97, i32 1
store i8* %98, i8** %8
%99 = load i8, i8* %97
%100 = sext i8 %99 to i32
%101 = load i32, i32* %11
%102 = add nsw i32 %101, %100
store i32 %102, i32* %11
br label %106
103: ; preds = %89
%104 = load i8*, i8** %8
%105 = getelementptr inbounds i8, i8* %104, i32 1
store i8* %105, i8** %8
br label %106
106: ; preds = %103, %96
br label %20
107: ; preds = %34
%108 = load i8*, i8** %8
%109 = getelementptr inbounds i8, i8* %108, i32 1
store i8* %109, i8** %8
%110 = load i8, i8* %108
%111 = sext i8 %110 to i32
%112 = load i32, i32* %11
%113 = add nsw i32 %112, %111
store i32 %113, i32* %11
br label %114
114: ; preds = %34, %107
%115 = load i32, i32* %11
%116 = trunc i32 %115 to i8
%117 = load i8*, i8** %9
%118 = getelementptr inbounds i8, i8* %117, i32 1
store i8* %118, i8** %9
store i8 %116, i8* %117
br label %77
119: ; preds = %34
store i32 1, i32* %12
br label %80
120: ; preds = %34
%121 = load i32, i32* %6
%122 = add nsw i32 %121, 1
store i32 %122, i32* %6
%123 = load i32, i32* %7
%124 = add nsw i32 %123, 1
store i32 %124, i32* %7
%125 = load i32, i32* %11
%126 = add nsw i32 %125, 1
store i32 %126, i32* %11
br label %20
127: ; preds = %34
%128 = load i32, i32* %10
%129 = trunc i32 %128 to i8
%130 = load i8*, i8** %9
%131 = getelementptr inbounds i8, i8* %130, i32 1
store i8* %131, i8** %9
store i8 %129, i8* %130
br label %20
132: ; preds = %34
%133 = load i8*, i8** %8
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
store i32 %135, i32* %10
%136 = load i32, i32* %11
%137 = load i32, i32* %10
%138 = sdiv i32 %136, %137
%139 = or i32 %138, 48
%140 = trunc i32 %139 to i8
%141 = load i8*, i8** %9
%142 = getelementptr inbounds i8, i8* %141, i32 1
store i8* %142, i8** %9
store i8 %140, i8* %141
%143 = load i8*, i8** %8
%144 = getelementptr inbounds i8, i8* %143, i32 1
store i8* %144, i8** %8
%145 = load i8, i8* %143
%146 = sext i8 %145 to i32
%147 = load i32, i32* %11
%148 = srem i32 %147, %146
store i32 %148, i32* %11
br label %20
149: ; preds = %34
%150 = load i32, i32* %11
%151 = sdiv i32 %150, 10
%152 = shl i32 %151, 4
%153 = load i32, i32* %11
%154 = srem i32 %153, 10
%155 = add nsw i32 %152, %154
store i32 %155, i32* %11
br label %20
156: ; preds = %34
%157 = load i32, i32* %11
%158 = load i32, i32* %11
%159 = srem i32 %158, 16
%160 = mul nsw i32 2, %159
%161 = sub nsw i32 %157, %160
store i32 %161, i32* %11
br label %20
162: ; preds = %34, %34, %34, %34, %34
%163 = load i8*, i8** %9
%164 = load i8*, i8** %8
%165 = getelementptr inbounds i8, i8* %164, i64 -2
%166 = load i32, i32* %7
%167 = load i32, i32* %6
%168 = call i32 (i8*, i8*, i32, i32, ...) bitcast (i32 (...)* @tparm to i32 (i8*, i8*, i32, i32, ...)*)(i8* %163, i8* %165, i32 %166, i32 %167)
store i8* getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), i8** %4
br label %172
169: ; preds = %34
br label %17
170: ; preds = %20
%171 = load i8*, i8** %9
store i8 0, i8* %171
store i8* getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), i8** %4
br label %172
172: ; preds = %170, %162, %17
%173 = load i8*, i8** %4
ret i8* %173
}

LLVM IR (-O2):
@CapGoto.result = internal global [64 x i8] zeroinitializer
@.str = [12 x i8] c"bad capgoto\00"
define i8* @CapGoto(i8* %0, i32 %1, i32 %2) {
%4 = icmp eq i8* %0, null
br i1 %4, label %116, label %5
5: ; preds = %3, %20
%6 = phi i32 [ %21, %20 ], [ %1, %3 ]
%7 = phi i32 [ %22, %20 ], [ %2, %3 ]
%8 = phi i8* [ %23, %20 ], [ %0, %3 ]
%9 = phi i8* [ %24, %20 ], [ getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), %3 ]
%10 = phi i32 [ %25, %20 ], [ %2, %3 ]
%11 = phi i32 [ %26, %20 ], [ 0, %3 ]
%12 = getelementptr inbounds i8, i8* %8, i64 1
%13 = load i8, i8* %8
switch i8 %13, label %14 [
i8 0, label %115
i8 37, label %16
]
14: ; preds = %5
%15 = getelementptr inbounds i8, i8* %9, i64 1
store i8 %13, i8* %9
br label %20
16: ; preds = %5
%17 = getelementptr inbounds i8, i8* %8, i64 2
%18 = load i8, i8* %12
%19 = sext i8 %18 to i32
switch i32 %19, label %116 [
i32 110, label %27
i32 100, label %30
i32 51, label %34
i32 50, label %40
i32 62, label %66
i32 43, label %78
i32 46, label %83
i32 114, label %20
i32 105, label %87
i32 37, label %91
i32 47, label %93
i32 66, label %104
i32 68, label %109
i32 112, label %113
i32 80, label %113
i32 39, label %113
i32 123, label %113
i32 63, label %113
]
20: ; preds = %16, %58, %14, %75, %87, %91, %93, %104, %109
%21 = phi i32 [ %6, %14 ], [ %6, %109 ], [ %6, %104 ], [ %6, %93 ], [ %6, %91 ], [ %88, %87 ], [ %6, %75 ], [ %6, %16 ], [ %59, %58 ]
%22 = phi i32 [ %7, %14 ], [ %7, %109 ], [ %7, %104 ], [ %7, %93 ], [ %7, %91 ], [ %89, %87 ], [ %7, %75 ], [ %7, %16 ], [ %60, %58 ]
%23 = phi i8* [ %12, %14 ], [ %17, %109 ], [ %17, %104 ], [ %100, %93 ], [ %17, %91 ], [ %17, %87 ], [ %77, %75 ], [ %17, %16 ], [ %61, %58 ]
%24 = phi i8* [ %15, %14 ], [ %9, %109 ], [ %9, %104 ], [ %99, %93 ], [ %92, %91 ], [ %9, %87 ], [ %9, %75 ], [ %9, %16 ], [ %62, %58 ]
%25 = phi i32 [ %10, %14 ], [ %112, %109 ], [ %108, %104 ], [ %103, %93 ], [ %10, %91 ], [ %90, %87 ], [ %76, %75 ], [ %6, %16 ], [ %65, %58 ]
%26 = phi i32 [ %11, %14 ], [ %11, %109 ], [ %11, %104 ], [ %11, %93 ], [ %11, %91 ], [ %11, %87 ], [ %11, %75 ], [ 1, %16 ], [ %63, %58 ]
br label %5
27: ; preds = %16
%28 = xor i32 %6, 96
%29 = xor i32 %7, 96
br label %58
30: ; preds = %16
%31 = icmp slt i32 %10, 10
br i1 %31, label %47, label %32
32: ; preds = %30
%33 = icmp ult i32 %10, 100
br i1 %33, label %40, label %34
34: ; preds = %32, %16
%35 = sdiv i32 %10, 100
%36 = trunc i32 %35 to i8
%37 = or i8 %36, 48
%38 = getelementptr inbounds i8, i8* %9, i64 1
store i8 %37, i8* %9
%39 = srem i32 %10, 100
br label %40
40: ; preds = %34, %16, %32
%41 = phi i8* [ %9, %16 ], [ %38, %34 ], [ %9, %32 ]
%42 = phi i32 [ %10, %16 ], [ %39, %34 ], [ %10, %32 ]
%43 = sdiv i32 %42, 10
%44 = trunc i32 %43 to i8
%45 = or i8 %44, 48
%46 = getelementptr inbounds i8, i8* %41, i64 1
store i8 %45, i8* %41
br label %47
47: ; preds = %30, %40
%48 = phi i8* [ %46, %40 ], [ %9, %30 ]
%49 = phi i32 [ %42, %40 ], [ %10, %30 ]
%50 = srem i32 %49, 10
%51 = trunc i32 %50 to i8
%52 = or i8 %51, 48
store i8 %52, i8* %48
br label %53
53: ; preds = %83, %47
%54 = phi i8* [ %84, %83 ], [ %17, %47 ]
%55 = phi i8* [ %9, %83 ], [ %48, %47 ]
%56 = getelementptr inbounds i8, i8* %55, i64 1
%57 = sub nsw i32 1, %11
br label %58
58: ; preds = %53, %27
%59 = phi i32 [ %6, %53 ], [ %28, %27 ]
%60 = phi i32 [ %7, %53 ], [ %29, %27 ]
%61 = phi i8* [ %54, %53 ], [ %17, %27 ]
%62 = phi i8* [ %56, %53 ], [ %9, %27 ]
%63 = phi i32 [ %57, %53 ], [ %11, %27 ]
%64 = icmp eq i32 %63, 0
%65 = select i1 %64, i32 %60, i32 %59
br label %20
66: ; preds = %16
%67 = load i8, i8* %17
%68 = sext i8 %67 to i32
%69 = icmp sgt i32 %10, %68
br i1 %69, label %70, label %75
70: ; preds = %66
%71 = getelementptr inbounds i8, i8* %8, i64 3
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = add nsw i32 %10, %73
br label %75
75: ; preds = %66, %70
%76 = phi i32 [ %74, %70 ], [ %10, %66 ]
%77 = getelementptr inbounds i8, i8* %8, i64 4
br label %20
78: ; preds = %16
%79 = getelementptr inbounds i8, i8* %8, i64 3
%80 = load i8, i8* %17
%81 = zext i8 %80 to i32
%82 = add i32 %10, %81
br label %83
83: ; preds = %16, %78
%84 = phi i8* [ %17, %16 ], [ %79, %78 ]
%85 = phi i32 [ %10, %16 ], [ %82, %78 ]
%86 = trunc i32 %85 to i8
store i8 %86, i8* %9
br label %53
87: ; preds = %16
%88 = add nsw i32 %6, 1
%89 = add nsw i32 %7, 1
%90 = add nsw i32 %10, 1
br label %20
91: ; preds = %16
%92 = getelementptr inbounds i8, i8* %9, i64 1
store i8 %18, i8* %9
br label %20
93: ; preds = %16
%94 = load i8, i8* %17
%95 = sext i8 %94 to i32
%96 = sdiv i32 %10, %95
%97 = trunc i32 %96 to i8
%98 = or i8 %97, 48
%99 = getelementptr inbounds i8, i8* %9, i64 1
store i8 %98, i8* %9
%100 = getelementptr inbounds i8, i8* %8, i64 3
%101 = load i8, i8* %17
%102 = sext i8 %101 to i32
%103 = srem i32 %10, %102
br label %20
104: ; preds = %16
%105 = sdiv i32 %10, 10
%106 = shl i32 %105, 4
%107 = srem i32 %10, 10
%108 = add nsw i32 %106, %107
br label %20
109: ; preds = %16
%110 = srem i32 %10, 16
%111 = mul nsw i32 %110, -2
%112 = add i32 %111, %10
br label %20
113: ; preds = %16, %16, %16, %16, %16
%114 = tail call i32 (i8*, i8*, i32, i32, ...) bitcast (i32 (...)* @tparm to i32 (i8*, i8*, i32, i32, ...)*)(i8* %9, i8* %8, i32 %7, i32 %6)
br label %116
115: ; preds = %5
store i8 0, i8* %9
br label %116
116: ; preds = %16, %3, %115, %113
%117 = phi i8* [ getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), %113 ], [ getelementptr inbounds ([64 x i8], [64 x i8]* @CapGoto.result, i64 0, i64 0), %115 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), %3 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), %16 ]
ret i8* %117
}