int execIFactor(char **str, unsigned char *bPtr, char bitpos, char *pPtr,
                char *err) {
  char nstring[100];
  int expression;
  int factor;
  char *nPtr;
  char *item;
  char token;
  int n;
  switch (nextToken(str, &item, &n)) {
  case 200:
    return (((int)bPtr[0]) & 0xff);
  case 201:
    return (((int)bPtr[1]) & 0xff);
  case 202:
    return (((int)bPtr[2]) & 0xff);
  case 203:
    return (((int)bPtr[3]) & 0xff);
  case 204:
    return (((int)bPtr[4]) & 0xff);
  case 205:
    return (((int)bPtr[5]) & 0xff);
  case 206:
    return (((int)bPtr[6]) & 0xff);
  case 207:
    return (((int)bPtr[7]) & 0xff);
  case 208:
    return (((int)bPtr[8]) & 0xff);
  case 209:
    return (((int)bPtr[9]) & 0xff);
  case 220:
    return (((int)bitpos) & 0xff);
  case 210:
    return (((int)pPtr[0]) & 0xff);
  case 211:
    return (((int)pPtr[1]) & 0xff);
  case 212:
    return (((int)pPtr[2]) & 0xff);
  case 213:
    return (((int)pPtr[3]) & 0xff);
  case 214:
    return (((int)pPtr[4]) & 0xff);
  case 215:
    return (((int)pPtr[5]) & 0xff);
  case 216:
    return (((int)pPtr[6]) & 0xff);
  case 217:
    return (((int)pPtr[7]) & 0xff);
  case 218:
    return (((int)pPtr[8]) & 0xff);
  case 219:
    return (((int)pPtr[9]) & 0xff);
  case 8:
    nPtr = nstring;
    bzero(nstring, sizeof(nstring));
    strcpy(nstring, "0x");
    nPtr += 2;
    token = nextToken(str, &item, &n);
    while ((token == 11) || (token == 10)) {
      *nPtr++ = *item;
      token = nextToken(str, &item, &n);
    };
    pushBack(str, n);
    sscanf(nstring, "%i", &factor);
    return (factor);
  case 11:
    nPtr = nstring;
    do {
      *nPtr++ = *item;
    } while ((token = nextToken(str, &item, &n)) == 11);
    if (token == 12) {
      do {
        *nPtr++ = *item;
      } while ((token = nextToken(str, &item, &n)) == 11);
    }
    pushBack(str, n);
    *nPtr = '\0';
    factor = atof(nstring);
    return (factor);
  case 110:
    expression = execIExpression(str, bPtr, bitpos, pPtr, err);
    if (*err) {
      return (0);
    }
    if (nextToken(str, &item, &n) != 111) {
      sprintf(err, "factor Erwartet:) [%c]\n", *item);
      return (0);
    }
    return (expression);
  case 400:
    return (~execIFactor(str, bPtr, bitpos, pPtr, err));
  default:
    sprintf(err, "factor Erwartet: B0..B9 P0..P9 BP Zahl ( ) [%c]\n", *item);
    return (0);
  }
}


x86 assembly (clang, -O0):
<execIFactor>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %dl,%al
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %al,-0x19(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
xor    %eax,%eax
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
call   1060 <nextToken@plt>
mov    %eax,%ecx
mov    %ecx,-0xc4(%rbp)
sub    $0x8,%eax
je     159e <execIFactor+0x40e>
jmp    11df <execIFactor+0x4f>
mov    -0xc4(%rbp),%eax
sub    $0xb,%eax
je     16c0 <execIFactor+0x530>
jmp    11f3 <execIFactor+0x63>
mov    -0xc4(%rbp),%eax
sub    $0x6e,%eax
je     17bb <execIFactor+0x62b>
jmp    1207 <execIFactor+0x77>
mov    -0xc4(%rbp),%eax
sub    $0xc8,%eax
je     13eb <execIFactor+0x25b>
jmp    121d <execIFactor+0x8d>
mov    -0xc4(%rbp),%eax
sub    $0xc9,%eax
je     13ff <execIFactor+0x26f>
jmp    1233 <execIFactor+0xa3>
mov    -0xc4(%rbp),%eax
sub    $0xca,%eax
je     1414 <execIFactor+0x284>
jmp    1249 <execIFactor+0xb9>
mov    -0xc4(%rbp),%eax
sub    $0xcb,%eax
je     1429 <execIFactor+0x299>
jmp    125f <execIFactor+0xcf>
mov    -0xc4(%rbp),%eax
sub    $0xcc,%eax
je     143e <execIFactor+0x2ae>
jmp    1275 <execIFactor+0xe5>
mov    -0xc4(%rbp),%eax
sub    $0xcd,%eax
je     1453 <execIFactor+0x2c3>
jmp    128b <execIFactor+0xfb>
mov    -0xc4(%rbp),%eax
sub    $0xce,%eax
je     1468 <execIFactor+0x2d8>
jmp    12a1 <execIFactor+0x111>
mov    -0xc4(%rbp),%eax
sub    $0xcf,%eax
je     147d <execIFactor+0x2ed>
jmp    12b7 <execIFactor+0x127>
mov    -0xc4(%rbp),%eax
sub    $0xd0,%eax
je     1492 <execIFactor+0x302>
jmp    12cd <execIFactor+0x13d>
mov    -0xc4(%rbp),%eax
sub    $0xd1,%eax
je     14a7 <execIFactor+0x317>
jmp    12e3 <execIFactor+0x153>
mov    -0xc4(%rbp),%eax
sub    $0xd2,%eax
je     14cd <execIFactor+0x33d>
jmp    12f9 <execIFactor+0x169>
mov    -0xc4(%rbp),%eax
sub    $0xd3,%eax
je     14e1 <execIFactor+0x351>
jmp    130f <execIFactor+0x17f>
mov    -0xc4(%rbp),%eax
sub    $0xd4,%eax
je     14f6 <execIFactor+0x366>
jmp    1325 <execIFactor+0x195>
mov    -0xc4(%rbp),%eax
sub    $0xd5,%eax
je     150b <execIFactor+0x37b>
jmp    133b <execIFactor+0x1ab>
mov    -0xc4(%rbp),%eax
sub    $0xd6,%eax
je     1520 <execIFactor+0x390>
jmp    1351 <execIFactor+0x1c1>
mov    -0xc4(%rbp),%eax
sub    $0xd7,%eax
je     1535 <execIFactor+0x3a5>
jmp    1367 <execIFactor+0x1d7>
mov    -0xc4(%rbp),%eax
sub    $0xd8,%eax
je     154a <execIFactor+0x3ba>
jmp    137d <execIFactor+0x1ed>
mov    -0xc4(%rbp),%eax
sub    $0xd9,%eax
je     155f <execIFactor+0x3cf>
jmp    1393 <execIFactor+0x203>
mov    -0xc4(%rbp),%eax
sub    $0xda,%eax
je     1574 <execIFactor+0x3e4>
jmp    13a9 <execIFactor+0x219>
mov    -0xc4(%rbp),%eax
sub    $0xdb,%eax
je     1589 <execIFactor+0x3f9>
jmp    13bf <execIFactor+0x22f>
mov    -0xc4(%rbp),%eax
sub    $0xdc,%eax
je     14bc <execIFactor+0x32c>
jmp    13d5 <execIFactor+0x245>
mov    -0xc4(%rbp),%eax
sub    $0x190,%eax
je     184d <execIFactor+0x6bd>
jmp    1873 <execIFactor+0x6e3>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x4(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x5(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x6(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x7(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x8(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x18(%rbp),%rax
movzbl 0x9(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
movsbl -0x19(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x3(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x4(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x5(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x6(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x7(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x8(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x28(%rbp),%rax
movsbl 0x9(%rax),%eax
and    $0xff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
lea    -0xa0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1080 <memset@plt>
lea    -0xa0(%rbp),%rdi
lea    0xa33(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0xb0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1060 <nextToken@plt>
mov    %al,-0xb9(%rbp)
movsbl -0xb9(%rbp),%ecx
mov    $0x1,%al
cmp    $0xb,%ecx
mov    %al,-0xc5(%rbp)
je     162e <execIFactor+0x49e>
movsbl -0xb9(%rbp),%eax
cmp    $0xa,%eax
sete   %al
mov    %al,-0xc5(%rbp)
mov    -0xc5(%rbp),%al
test   $0x1,%al
jne    1641 <execIFactor+0x4b1>
jmp    1685 <execIFactor+0x4f5>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0xb0(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rdi
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1060 <nextToken@plt>
mov    %al,-0xb9(%rbp)
jmp    1603 <execIFactor+0x473>
mov    -0x10(%rbp),%rdi
mov    -0xc0(%rbp),%esi
mov    $0x0,%al
call   1050 <pushBack@plt>
lea    -0xa0(%rbp),%rdi
lea    0x95f(%rip),%rsi
lea    -0xa8(%rbp),%rdx
mov    $0x0,%al
call   1090 <sscanf@plt>
mov    -0xa8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
lea    -0xa0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0xb0(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rdi
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1060 <nextToken@plt>
mov    %al,-0xb9(%rbp)
movsbl %al,%eax
cmp    $0xb,%eax
je     16ce <execIFactor+0x53e>
movsbl -0xb9(%rbp),%eax
cmp    $0xc,%eax
jne    177e <execIFactor+0x5ee>
jmp    172e <execIFactor+0x59e>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0xb0(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0xb0(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rdi
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1060 <nextToken@plt>
mov    %al,-0xb9(%rbp)
movsbl %al,%eax
cmp    $0xb,%eax
je     172e <execIFactor+0x59e>
jmp    177e <execIFactor+0x5ee>
mov    -0x10(%rbp),%rdi
mov    -0xc0(%rbp),%esi
mov    $0x0,%al
call   1050 <pushBack@plt>
mov    -0xb0(%rbp),%rax
movb   $0x0,(%rax)
lea    -0xa0(%rbp),%rdi
mov    $0x0,%al
call   1040 <atof@plt>
mov    %eax,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movsbl -0x19(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    $0x0,%al
call   10b0 <execIExpression@plt>
mov    %eax,-0xa4(%rbp)
mov    -0x30(%rbp),%rax
cmpb   $0x0,(%rax)
je     17f5 <execIFactor+0x665>
movl   $0x0,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x10(%rbp),%rdi
lea    -0xb8(%rbp),%rsi
lea    -0xc0(%rbp),%rdx
mov    $0x0,%al
call   1060 <nextToken@plt>
cmp    $0x6f,%eax
je     183f <execIFactor+0x6af>
mov    -0x30(%rbp),%rdi
mov    -0xb8(%rbp),%rax
movsbl (%rax),%edx
lea    0x7da(%rip),%rsi
mov    $0x0,%al
call   10a0 <sprintf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0xa4(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x19(%rbp),%al
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
movsbl %al,%edx
call   1070 <execIFactor@plt>
xor    $0xffffffff,%eax
mov    %eax,-0x4(%rbp)
jmp    1896 <execIFactor+0x706>
mov    -0x30(%rbp),%rdi
mov    -0xb8(%rbp),%rax
movsbl (%rax),%edx
lea    0x796(%rip),%rsi
mov    $0x0,%al
call   10a0 <sprintf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<execIFactor>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x90,%rsp
mov    %r8,%r14
mov    %rcx,%r12
mov    %edx,%r15d
mov    %rsi,%rbp
mov    %rdi,%rbx
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1050 <nextToken@plt>
lea    -0x8(%rax),%ecx
cmp    $0xd4,%ecx
ja     1279 <execIFactor+0x109>
lea    0xe4b(%rip),%rax
movslq (%rax,%rcx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
xorps  %xmm0,%xmm0
movups %xmm0,0x73(%rsp)
movups %xmm0,0x63(%rsp)
movups %xmm0,0x53(%rsp)
movups %xmm0,0x43(%rsp)
movups %xmm0,0x33(%rsp)
movups %xmm0,0x23(%rsp)
movb   $0x0,0x83(%rsp)
movw   $0x7830,0x20(%rsp)
movb   $0x0,0x22(%rsp)
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <nextToken@plt>
and    $0xfe,%eax
cmp    $0xa,%eax
jne    1249 <execIFactor+0xd9>
lea    0x22(%rsp),%rbp
lea    0x10(%rsp),%r14
lea    0xc(%rsp),%r15
mov    0x10(%rsp),%rax
movzbl (%rax),%eax
mov    %al,0x0(%rbp)
add    $0x1,%rbp
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1050 <nextToken@plt>
and    $0xfe,%eax
cmp    $0xa,%eax
je     1220 <execIFactor+0xb0>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <pushBack@plt>
lea    0x10f9(%rip),%rsi
lea    0x20(%rsp),%rdi
lea    0x1c(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
mov    0x1c(%rsp),%r15d
jmp    1466 <execIFactor+0x2f6>
cmp    $0x190,%eax
jne    12a0 <execIFactor+0x130>
movsbl %r15b,%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r12,%rcx
mov    %r14,%r8
call   1060 <execIFactor@plt>
mov    %eax,%r15d
not    %r15d
jmp    1466 <execIFactor+0x2f6>
mov    0x10(%rsp),%rax
movsbl (%rax),%edx
lea    0x10c3(%rip),%rsi
xor    %r15d,%r15d
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <sprintf@plt>
jmp    1466 <execIFactor+0x2f6>
lea    0x20(%rsp),%rbp
lea    0x10(%rsp),%r14
lea    0xc(%rsp),%r15
mov    0x10(%rsp),%rax
movzbl (%rax),%eax
mov    %al,0x0(%rbp)
add    $0x1,%rbp
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1050 <nextToken@plt>
shl    $0x18,%eax
cmp    $0xb000000,%eax
je     12d0 <execIFactor+0x160>
cmp    $0xc000000,%eax
jne    1333 <execIFactor+0x1c3>
lea    0x10(%rsp),%r14
lea    0xc(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
movzbl (%rax),%eax
mov    %al,0x0(%rbp)
add    $0x1,%rbp
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1050 <nextToken@plt>
cmp    $0xb,%al
je     1310 <execIFactor+0x1a0>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <pushBack@plt>
movb   $0x0,0x0(%rbp)
lea    0x20(%rsp),%rdi
xor    %eax,%eax
call   1030 <atof@plt>
mov    %eax,%r15d
mov    %eax,0x1c(%rsp)
jmp    1466 <execIFactor+0x2f6>
movsbl %r15b,%edx
xor    %r15d,%r15d
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r12,%rcx
mov    %r14,%r8
xor    %eax,%eax
call   1090 <execIExpression@plt>
cmpb   $0x0,(%r14)
jne    1466 <execIFactor+0x2f6>
mov    %eax,%ebp
lea    0x10(%rsp),%rsi
lea    0xc(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   1050 <nextToken@plt>
mov    %ebp,%r15d
cmp    $0x6f,%eax
je     1466 <execIFactor+0x2f6>
mov    0x10(%rsp),%rax
movsbl (%rax),%edx
lea    0xfa8(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <sprintf@plt>
xor    %r15d,%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x0(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x1(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x2(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x3(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x4(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x5(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x6(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x7(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x8(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x9(%rbp),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl (%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x1(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x2(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x3(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x4(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x5(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x6(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x7(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x8(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl 0x9(%r12),%r15d
jmp    1466 <execIFactor+0x2f6>
movzbl %r15b,%r15d
mov    %r15d,%eax
add    $0x90,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"0x\00"
@.str.1 = [3 x i8] c"%i\00"
@.str.2 = [24 x i8] c"factor Erwartet:) [%c]\0A\00"
@.str.3 = [49 x i8] c"factor Erwartet: B0..B9 P0..P9 BP Zahl ( ) [%c]\0A\00"
define i32 @execIFactor(i8** %0, i8* %1, i8 signext %2, i8* %3, i8* %4) {
%6 = alloca [100 x i8]
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%11 = bitcast i32* %7 to i8*
%12 = bitcast i8** %8 to i8*
%13 = bitcast i32* %9 to i8*
%14 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
switch i32 %14, label %151 [
i32 200, label %15
i32 201, label %18
i32 202, label %22
i32 203, label %26
i32 204, label %30
i32 205, label %34
i32 206, label %38
i32 207, label %42
i32 208, label %46
i32 209, label %50
i32 220, label %54
i32 210, label %56
i32 211, label %59
i32 212, label %63
i32 213, label %67
i32 214, label %71
i32 215, label %75
i32 216, label %79
i32 217, label %83
i32 218, label %87
i32 219, label %91
i32 8, label %95
i32 11, label %115
i32 110, label %135
i32 400, label %148
]
15: ; preds = %5
%16 = load i8, i8* %1
%17 = zext i8 %16 to i32
br label %156
18: ; preds = %5
%19 = getelementptr inbounds i8, i8* %1, i64 1
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
br label %156
22: ; preds = %5
%23 = getelementptr inbounds i8, i8* %1, i64 2
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
br label %156
26: ; preds = %5
%27 = getelementptr inbounds i8, i8* %1, i64 3
%28 = load i8, i8* %27
%29 = zext i8 %28 to i32
br label %156
30: ; preds = %5
%31 = getelementptr inbounds i8, i8* %1, i64 4
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
br label %156
34: ; preds = %5
%35 = getelementptr inbounds i8, i8* %1, i64 5
%36 = load i8, i8* %35
%37 = zext i8 %36 to i32
br label %156
38: ; preds = %5
%39 = getelementptr inbounds i8, i8* %1, i64 6
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
br label %156
42: ; preds = %5
%43 = getelementptr inbounds i8, i8* %1, i64 7
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
br label %156
46: ; preds = %5
%47 = getelementptr inbounds i8, i8* %1, i64 8
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
br label %156
50: ; preds = %5
%51 = getelementptr inbounds i8, i8* %1, i64 9
%52 = load i8, i8* %51
%53 = zext i8 %52 to i32
br label %156
54: ; preds = %5
%55 = zext i8 %2 to i32
br label %156
56: ; preds = %5
%57 = load i8, i8* %3
%58 = zext i8 %57 to i32
br label %156
59: ; preds = %5
%60 = getelementptr inbounds i8, i8* %3, i64 1
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
br label %156
63: ; preds = %5
%64 = getelementptr inbounds i8, i8* %3, i64 2
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
br label %156
67: ; preds = %5
%68 = getelementptr inbounds i8, i8* %3, i64 3
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
br label %156
71: ; preds = %5
%72 = getelementptr inbounds i8, i8* %3, i64 4
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
br label %156
75: ; preds = %5
%76 = getelementptr inbounds i8, i8* %3, i64 5
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
br label %156
79: ; preds = %5
%80 = getelementptr inbounds i8, i8* %3, i64 6
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
br label %156
83: ; preds = %5
%84 = getelementptr inbounds i8, i8* %3, i64 7
%85 = load i8, i8* %84
%86 = zext i8 %85 to i32
br label %156
87: ; preds = %5
%88 = getelementptr inbounds i8, i8* %3, i64 8
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
br label %156
91: ; preds = %5
%92 = getelementptr inbounds i8, i8* %3, i64 9
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
br label %156
95: ; preds = %5
%96 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 3
%97 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
%98 = and i32 %97, 254
%99 = icmp eq i32 %98, 10
br i1 %99, label %100, label %110
100: ; preds = %95
%101 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 2
br label %102
102: ; preds = %100, %102
%103 = phi i8* [ %106, %102 ], [ %101, %100 ]
%104 = load i8*, i8** %8
%105 = load i8, i8* %104
%106 = getelementptr inbounds i8, i8* %103, i64 1
store i8 %105, i8* %103
%107 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
%108 = and i32 %107, 254
%109 = icmp eq i32 %108, 10
br i1 %109, label %102, label %110
110: ; preds = %102, %95
%111 = load i32, i32* %9
%112 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @pushBack to i32 (i8**, i32, ...)*)(i8** %0, i32 %111)
%113 = call i32 (i8*, i8*, ...) @sscanf(i8* %10, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %7)
%114 = load i32, i32* %7
br label %156
115: ; preds = %5, %115
%116 = phi i8* [ %119, %115 ], [ %10, %5 ]
%117 = load i8*, i8** %8
%118 = load i8, i8* %117
%119 = getelementptr inbounds i8, i8* %116, i64 1
store i8 %118, i8* %116
%120 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
%121 = shl i32 %120, 24
switch i32 %121, label %130 [
i32 184549376, label %115
i32 201326592, label %122
]
122: ; preds = %115, %122
%123 = phi i8* [ %126, %122 ], [ %119, %115 ]
%124 = load i8*, i8** %8
%125 = load i8, i8* %124
%126 = getelementptr inbounds i8, i8* %123, i64 1
store i8 %125, i8* %123
%127 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
%128 = and i32 %127, 255
%129 = icmp eq i32 %128, 11
br i1 %129, label %122, label %130
130: ; preds = %115, %122
%131 = phi i8* [ %126, %122 ], [ %119, %115 ]
%132 = load i32, i32* %9
%133 = call i32 (i8**, i32, ...) bitcast (i32 (...)* @pushBack to i32 (i8**, i32, ...)*)(i8** %0, i32 %132)
store i8 0, i8* %131
%134 = call i32 (i8*, ...) bitcast (i32 (...)* @atof to i32 (i8*, ...)*)(i8* %10)
store i32 %134, i32* %7
br label %156
135: ; preds = %5
%136 = sext i8 %2 to i32
%137 = call i32 (i8**, i8*, i32, i8*, i8*, ...) bitcast (i32 (...)* @execIExpression to i32 (i8**, i8*, i32, i8*, i8*, ...)*)(i8** %0, i8* %1, i32 %136, i8* %3, i8* %4)
%138 = load i8, i8* %4
%139 = icmp eq i8 %138, 0
br i1 %139, label %140, label %156
140: ; preds = %135
%141 = call i32 (i8**, i8**, i32*, ...) bitcast (i32 (...)* @nextToken to i32 (i8**, i8**, i32*, ...)*)(i8** %0, i8** %8, i32* %9)
%142 = icmp eq i32 %141, 111
br i1 %142, label %156, label %143
143: ; preds = %140
%144 = load i8*, i8** %8
%145 = load i8, i8* %144
%146 = sext i8 %145 to i32
%147 = call i32 (i8*, i8*, ...) @sprintf(i8* %4, i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0), i32 %146)
br label %156
148: ; preds = %5
%149 = call i32 @execIFactor(i8** %0, i8* %1, i8 signext %2, i8* %3, i8* %4)
%150 = xor i32 %149, -1
br label %156
151: ; preds = %5
%152 = load i8*, i8** %8
%153 = load i8, i8* %152
%154 = sext i8 %153 to i32
%155 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %4, i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.3, i64 0, i64 0), i32 %154)
br label %156
156: ; preds = %140, %135, %151, %148, %143, %130, %110, %91, %87, %83, %79, %75, %71, %67, %63, %59, %56, %54, %50, %46, %42, %38, %34, %30, %26, %22, %18, %15
%157 = phi i32 [ 0, %151 ], [ %150, %148 ], [ 0, %143 ], [ %134, %130 ], [ %114, %110 ], [ %94, %91 ], [ %90, %87 ], [ %86, %83 ], [ %82, %79 ], [ %78, %75 ], [ %74, %71 ], [ %70, %67 ], [ %66, %63 ], [ %62, %59 ], [ %58, %56 ], [ %55, %54 ], [ %53, %50 ], [ %49, %46 ], [ %45, %42 ], [ %41, %38 ], [ %37, %34 ], [ %33, %30 ], [ %29, %26 ], [ %25, %22 ], [ %21, %18 ], [ %17, %15 ], [ 0, %135 ], [ %137, %140 ]
ret i32 %157
}