#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 blockLength(int, char *, int const);
scalar_t__ cci_bits(int const, char);
scalar_t__ mode_bits(int const);
int /*<<< orphan*/ printf(char *, int, int const, int const, int const);
int /*<<< orphan*/ qr_define_mode(char *, unsigned int const *, int const,
                                  int const, int const, int const);
int getBinaryLength(const int version, char inputMode[],
                    const unsigned int inputData[], const int inputLength,
                    const int gs1, const int eci, const int debug_print) {
  int i, j;
  char currentMode;
  int count = 0;
  int alphalength;
  int blocklength;
  qr_define_mode(inputMode, inputData, inputLength, gs1, version, debug_print);
  currentMode = ' ';
  if (gs1 == 1) {
    if (version < 41) {
      count += 4;
    } else {
      count += 3;
    }
  }
  if (eci != 0) {
    count += 4;
    if (eci <= 127) {
      count += 8;
    } else if (eci <= 16383) {
      count += 16;
    } else {
      count += 24;
    }
  }
  for (i = 0; i < inputLength; i++) {
    if (inputMode[i] != currentMode) {
      count += mode_bits(version) + cci_bits(version, inputMode[i]);
      blocklength = blockLength(i, inputMode, inputLength);
      switch (inputMode[i]) {
      case 'K':
        count += (blocklength * 13);
        break;
      case 'B':
        for (j = i; j < (i + blocklength); j++) {
          if (inputData[j] > 0xff) {
            count += 16;
          } else {
            count += 8;
          }
        }
        break;
      case 'A':
        alphalength = blocklength;
        if (gs1) {
          for (j = i; j < (i + blocklength); j++) {
            if (inputData[j] == '%') {
              alphalength++;
            }
          }
        }
        switch (alphalength % 2) {
        case 0:
          count += (alphalength / 2) * 11;
          break;
        case 1:
          count += ((alphalength - 1) / 2) * 11;
          count += 6;
          break;
        }
        break;
      case 'N':
        switch (blocklength % 3) {
        case 0:
          count += (blocklength / 3) * 10;
          break;
        case 1:
          count += ((blocklength - 1) / 3) * 10;
          count += 4;
          break;
        case 2:
          count += ((blocklength - 2) / 3) * 10;
          count += 7;
          break;
        }
        break;
      }
      currentMode = inputMode[i];
    }
  }
  if (debug_print) {
    printf("Estimated Binary Length: %d (version %d, eci %d, gs1 %d)\n", count,
           version, eci, gs1);
  }
  return count;
}


x86 assembly (clang, -O0):
<getBinaryLength>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x4(%rbp),%r8d
mov    0x10(%rbp),%r9d
call   1060 <qr_define_mode@plt>
movb   $0x20,-0x2d(%rbp)
cmpl   $0x1,-0x20(%rbp)
jne    11c7 <getBinaryLength+0x77>
cmpl   $0x29,-0x4(%rbp)
jge    11b9 <getBinaryLength+0x69>
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    11c2 <getBinaryLength+0x72>
mov    -0x34(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x34(%rbp)
jmp    11c7 <getBinaryLength+0x77>
cmpl   $0x0,-0x24(%rbp)
je     1220 <getBinaryLength+0xd0>
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x7f,-0x24(%rbp)
jg     11f2 <getBinaryLength+0xa2>
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    121b <getBinaryLength+0xcb>
cmpl   $0x3fff,-0x24(%rbp)
jg     120d <getBinaryLength+0xbd>
mov    -0x34(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x34(%rbp)
jmp    1216 <getBinaryLength+0xc6>
mov    -0x34(%rbp),%eax
add    $0x18,%eax
mov    %eax,-0x34(%rbp)
jmp    121b <getBinaryLength+0xcb>
jmp    1220 <getBinaryLength+0xd0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14c4 <getBinaryLength+0x374>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x2d(%rbp),%ecx
cmp    %ecx,%eax
je     14b1 <getBinaryLength+0x361>
mov    -0x4(%rbp),%edi
call   1030 <mode_bits@plt>
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
call   1050 <cci_bits@plt>
mov    -0x50(%rbp),%rcx
add    %eax,%ecx
mov    -0x34(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x1c(%rbp),%edx
call   1040 <blockLength@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0xd,%eax
ja     14a3 <getBinaryLength+0x353>
mov    -0x48(%rbp),%rax
lea    0xd4c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
imul   $0xd,-0x3c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    14a3 <getBinaryLength+0x353>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    1322 <getBinaryLength+0x1d2>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0xff,(%rax,%rcx,4)
jbe    1306 <getBinaryLength+0x1b6>
mov    -0x34(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x34(%rbp)
jmp    130f <getBinaryLength+0x1bf>
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    1314 <getBinaryLength+0x1c4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d2 <getBinaryLength+0x182>
jmp    14a3 <getBinaryLength+0x353>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     1381 <getBinaryLength+0x231>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    137c <getBinaryLength+0x22c>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1369 <getBinaryLength+0x219>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    136e <getBinaryLength+0x21e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    133d <getBinaryLength+0x1ed>
jmp    1381 <getBinaryLength+0x231>
mov    -0x38(%rbp),%eax
mov    %eax,%edx
shr    $0x1f,%edx
mov    %eax,%ecx
add    %edx,%ecx
and    $0xfffffffe,%ecx
sub    %ecx,%eax
mov    %eax,-0x54(%rbp)
je     13b1 <getBinaryLength+0x261>
jmp    13a0 <getBinaryLength+0x250>
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
je     13ca <getBinaryLength+0x27a>
jmp    13ea <getBinaryLength+0x29a>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
imul   $0xb,%eax,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    13ea <getBinaryLength+0x29a>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
imul   $0xb,%eax,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x34(%rbp)
jmp    14a3 <getBinaryLength+0x353>
movslq -0x3c(%rbp),%rcx
mov    %ecx,%eax
imul   $0x55555556,%rcx,%rdx
mov    %rdx,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rdx
add    %ecx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
je     1440 <getBinaryLength+0x2f0>
jmp    141e <getBinaryLength+0x2ce>
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
je     1459 <getBinaryLength+0x309>
jmp    142f <getBinaryLength+0x2df>
mov    -0x58(%rbp),%eax
sub    $0x2,%eax
je     147e <getBinaryLength+0x32e>
jmp    149e <getBinaryLength+0x34e>
mov    -0x3c(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    149e <getBinaryLength+0x34e>
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    149e <getBinaryLength+0x34e>
mov    -0x3c(%rbp),%eax
sub    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x34(%rbp)
jmp    14a3 <getBinaryLength+0x353>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x2d(%rbp)
jmp    14b6 <getBinaryLength+0x366>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1227 <getBinaryLength+0xd7>
cmpl   $0x0,0x10(%rbp)
je     14e7 <getBinaryLength+0x397>
mov    -0x34(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%r8d
lea    0xb56(%rip),%rdi
call   1070 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getBinaryLength>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r15d
mov    %r8d,%ebx
mov    %ecx,%r13d
mov    %edi,%ebp
mov    0x80(%rsp),%r9d
mov    %rsi,0x20(%rsp)
mov    %rsi,%rdi
mov    %rdx,0x38(%rsp)
mov    %rdx,%rsi
mov    %ecx,%edx
mov    %r8d,%ecx
mov    %ebp,%r8d
call   1060 <qr_define_mode@plt>
xor    %eax,%eax
mov    %ebp,0x1c(%rsp)
cmp    $0x29,%ebp
setl   %al
add    $0x3,%eax
xor    %r14d,%r14d
mov    %ebx,0x18(%rsp)
cmp    $0x1,%ebx
cmove  %eax,%r14d
test   %r15d,%r15d
je     11cf <getBinaryLength+0x7f>
cmp    $0x7f,%r15d
jg     11bc <getBinaryLength+0x6c>
add    $0xc,%r14d
jmp    11cf <getBinaryLength+0x7f>
cmp    $0x3fff,%r15d
ja     11cb <getBinaryLength+0x7b>
add    $0x14,%r14d
jmp    11cf <getBinaryLength+0x7f>
add    $0x1c,%r14d
mov    %r15d,0x2c(%rsp)
test   %r13d,%r13d
jle    1759 <getBinaryLength+0x609>
mov    %r13d,%r11d
mov    0x38(%rsp),%rax
lea    0x30(%rax),%rbp
mov    $0x20,%r10b
mov    $0x1,%r9d
xor    %ebx,%ebx
xor    %ecx,%ecx
xor    %edi,%edi
mov    0x20(%rsp),%r15
mov    %r11,0x30(%rsp)
jmp    1228 <getBinaryLength+0xd8>
lea    (%rax,%rax,2),%edx
lea    (%rax,%rdx,4),%eax
add    %eax,%r14d
nopl   (%rax)
add    $0x4,%rbp
add    $0x1,%r9
add    $0x1,%ecx
add    $0xffffffffffffffff,%rbx
cmp    %r11,%rdi
je     1759 <getBinaryLength+0x609>
mov    %rdi,%r12
add    $0x1,%rdi
cmp    %r10b,(%r15,%r12,1)
je     1210 <getBinaryLength+0xc0>
mov    %rdi,0x10(%rsp)
mov    %ecx,0x4(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r9,0x40(%rsp)
mov    0x1c(%rsp),%r15d
mov    %r15d,%edi
call   1030 <mode_bits@plt>
mov    %r13d,%ebx
mov    %rax,%r13
mov    0x20(%rsp),%rax
movsbl (%rax,%r12,1),%esi
mov    %r15d,%edi
mov    0x20(%rsp),%r15
call   1050 <cci_bits@plt>
add    %eax,%r13d
add    %r13d,%r14d
mov    %ebx,%r13d
mov    %r12d,%edi
mov    %r15,%rsi
mov    %ebx,%edx
call   1040 <blockLength@plt>
movsbl (%r15,%r12,1),%r10d
mov    %r10d,%edx
add    $0xffffffbf,%edx
cmp    $0xd,%edx
ja     1615 <getBinaryLength+0x4c5>
lea    0xdad(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
mov    0x38(%rsp),%r8
mov    0x30(%rsp),%r11
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%rbx
movdqa 0xd3a(%rip),%xmm6
movdqa 0xd42(%rip),%xmm7
movdqa 0xd49(%rip),%xmm8
movdqa 0xd50(%rip),%xmm9
movdqa 0xd57(%rip),%xmm10
mov    0x4(%rsp),%ecx
mov    0x10(%rsp),%rdi
jmp    *%rdx
cmpl   $0x0,0x18(%rsp)
je     16d6 <getBinaryLength+0x586>
test   %eax,%eax
jle    16d6 <getBinaryLength+0x586>
lea    (%rax,%r12,1),%edx
movslq %edx,%rdx
cmp    %rdx,%rdi
mov    %rdx,%rsi
cmovg  %rdi,%rsi
sub    %r12,%rsi
cmp    $0x8,%rsi
jb     16c0 <getBinaryLength+0x570>
mov    %rsi,%rbx
and    $0xfffffffffffffff8,%rbx
movd   %eax,%xmm0
lea    -0x8(%rbx),%rdi
mov    %rdi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdi,%rdi
je     1745 <getBinaryLength+0x5f5>
add    0x4(%rsp),%eax
movslq %eax,%rdi
cmp    %rdi,%r9
cmovg  %r9,%rdi
add    0x8(%rsp),%rdi
and    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm1,%xmm1
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%rbp,%rax,4),%xmm2
movdqu -0x20(%rbp,%rax,4),%xmm3
movdqu -0x10(%rbp,%rax,4),%xmm4
movdqu 0x0(%rbp,%rax,4),%xmm5
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
pcmpeqd %xmm6,%xmm3
psubd  %xmm3,%xmm1
pcmpeqd %xmm6,%xmm4
psubd  %xmm4,%xmm0
pcmpeqd %xmm6,%xmm5
psubd  %xmm5,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1380 <getBinaryLength+0x230>
test   $0x1,%cl
je     13e7 <getBinaryLength+0x297>
add    %r12,%rax
movdqu (%r8,%rax,4),%xmm2
movdqu 0x10(%r8,%rax,4),%xmm3
pcmpeqd %xmm6,%xmm2
psubd  %xmm2,%xmm0
pcmpeqd %xmm6,%xmm3
psubd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %rbx,%rsi
mov    0x4(%rsp),%ecx
jne    16b3 <getBinaryLength+0x563>
mov    0x8(%rsp),%rbx
jmp    16d6 <getBinaryLength+0x586>
test   %eax,%eax
jle    1210 <getBinaryLength+0xc0>
lea    (%rax,%r12,1),%edx
movslq %edx,%rdx
cmp    %rdx,%rdi
mov    %rdx,%rsi
cmovg  %rdi,%rsi
sub    %r12,%rsi
cmp    $0x8,%rsi
jb     1690 <getBinaryLength+0x540>
mov    %rsi,%rbx
and    $0xfffffffffffffff8,%rbx
movd   %r14d,%xmm0
lea    -0x8(%rbx),%rdi
mov    %rdi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdi,%rdi
je     1731 <getBinaryLength+0x5e1>
add    0x4(%rsp),%eax
movslq %eax,%rdi
cmp    %rdi,%r9
cmovg  %r9,%rdi
add    0x8(%rsp),%rdi
and    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm3,%xmm3
xor    %eax,%eax
movdqa %xmm0,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x30(%rbp,%rax,4),%xmm4
movdqu -0x20(%rbp,%rax,4),%xmm2
movdqu -0x10(%rbp,%rax,4),%xmm0
movdqu 0x0(%rbp,%rax,4),%xmm1
pxor   %xmm7,%xmm4
pcmpgtd %xmm8,%xmm4
pxor   %xmm7,%xmm2
pcmpgtd %xmm8,%xmm2
movdqa %xmm4,%xmm6
pandn  %xmm9,%xmm6
pand   %xmm10,%xmm4
por    %xmm6,%xmm4
paddd  %xmm5,%xmm4
movdqa %xmm2,%xmm5
pandn  %xmm9,%xmm5
pand   %xmm10,%xmm2
por    %xmm5,%xmm2
paddd  %xmm3,%xmm2
pxor   %xmm7,%xmm0
pcmpgtd %xmm8,%xmm0
pxor   %xmm7,%xmm1
pcmpgtd %xmm8,%xmm1
movdqa %xmm0,%xmm3
pandn  %xmm9,%xmm3
pand   %xmm10,%xmm0
por    %xmm3,%xmm0
paddd  %xmm4,%xmm0
movdqa %xmm1,%xmm3
pandn  %xmm9,%xmm3
pand   %xmm10,%xmm1
por    %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rax
movdqa %xmm0,%xmm5
movdqa %xmm1,%xmm3
add    $0xfffffffffffffffe,%rdi
jne    14a0 <getBinaryLength+0x350>
test   $0x1,%cl
je     159d <getBinaryLength+0x44d>
add    %r12,%rax
movdqu (%r8,%rax,4),%xmm2
movdqu 0x10(%r8,%rax,4),%xmm3
pxor   %xmm7,%xmm2
pcmpgtd %xmm8,%xmm2
pxor   %xmm7,%xmm3
pcmpgtd %xmm8,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm9,%xmm4
pand   %xmm10,%xmm2
por    %xmm4,%xmm2
paddd  %xmm2,%xmm0
movdqa %xmm3,%xmm2
pandn  %xmm9,%xmm2
pand   %xmm10,%xmm3
por    %xmm2,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r14d
cmp    %rbx,%rsi
mov    0x4(%rsp),%ecx
mov    0x10(%rsp),%rdi
jne    167f <getBinaryLength+0x52f>
mov    0x8(%rsp),%rbx
jmp    1210 <getBinaryLength+0xc0>
movslq %eax,%rdx
imul   $0x55555556,%rdx,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
shr    $0x20,%rdx
add    %esi,%edx
lea    (%rdx,%rdx,2),%edi
mov    %eax,%esi
sub    %edi,%esi
cmp    $0x2,%esi
je     162d <getBinaryLength+0x4dd>
cmp    $0x1,%esi
je     1656 <getBinaryLength+0x506>
test   %esi,%esi
mov    0x10(%rsp),%rdi
jne    1210 <getBinaryLength+0xc0>
lea    (%rdx,%rdx,4),%eax
lea    (%r14,%rax,2),%r14d
jmp    1210 <getBinaryLength+0xc0>
mov    0x30(%rsp),%r11
mov    0x40(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x4(%rsp),%ecx
jmp    1727 <getBinaryLength+0x5d7>
add    $0xfffffffe,%eax
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rax
add    %edx,%eax
lea    (%rax,%rax,4),%eax
lea    (%r14,%rax,2),%r14d
add    $0x7,%r14d
jmp    1727 <getBinaryLength+0x5d7>
add    $0xffffffff,%eax
cltq
imul   $0x55555556,%rax,%rax
mov    %rax,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rax
add    %edx,%eax
lea    (%rax,%rax,4),%eax
lea    (%r14,%rax,2),%r14d
add    $0x4,%r14d
jmp    1727 <getBinaryLength+0x5d7>
add    %rbx,%r12
mov    0x8(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
cmpl   $0x100,(%r8,%r12,4)
setae  %al
lea    (%r14,%rax,8),%r14d
add    $0x8,%r14d
add    $0x1,%r12
cmp    %rdx,%r12
jl     1690 <getBinaryLength+0x540>
jmp    1210 <getBinaryLength+0xc0>
add    %rbx,%r12
mov    0x8(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
cmpl   $0x25,(%r8,%r12,4)
sete   %sil
add    %esi,%eax
add    $0x1,%r12
cmp    %rdx,%r12
jl     16c0 <getBinaryLength+0x570>
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
mov    %edx,%edi
and    $0xfffffffe,%edi
mov    %eax,%esi
sub    %edi,%esi
cmp    $0x1,%esi
je     170b <getBinaryLength+0x5bb>
test   %esi,%esi
mov    0x10(%rsp),%rdi
jne    1210 <getBinaryLength+0xc0>
sar    %edx
lea    (%rdx,%rdx,4),%eax
lea    (%rdx,%rax,2),%eax
add    %r14d,%eax
mov    %eax,%r14d
jmp    1210 <getBinaryLength+0xc0>
mov    %eax,%edx
add    $0xffffffff,%edx
shr    $0x1f,%edx
add    %edx,%eax
add    $0xffffffff,%eax
sar    %eax
lea    (%rax,%rax,4),%edx
lea    (%rax,%rdx,2),%eax
add    %eax,%r14d
add    $0x6,%r14d
mov    0x10(%rsp),%rdi
jmp    1210 <getBinaryLength+0xc0>
pxor   %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%cl
jne    154f <getBinaryLength+0x3ff>
jmp    159d <getBinaryLength+0x44d>
pxor   %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%cl
jne    13c7 <getBinaryLength+0x277>
jmp    13e7 <getBinaryLength+0x297>
cmpl   $0x0,0x80(%rsp)
je     177f <getBinaryLength+0x62f>
lea    0x91e(%rip),%rdi
mov    %r14d,%esi
mov    0x1c(%rsp),%edx
mov    0x2c(%rsp),%ecx
mov    0x18(%rsp),%r8d
call   1070 <printf@plt>
mov    %r14d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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