#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(size_t, char *, size_t 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 *, size_t const,
                                  int const, int const, int const);
int getBinaryLength(const int version, char inputMode[],
                    const unsigned int inputData[], const size_t inputLength,
                    const int gs1, const int eci, const int debug) {
  size_t i, j;
  char currentMode;
  int count = 0;
  int alphalength;
  int blocklength;
  qr_define_mode(inputMode, inputData, inputLength, gs1, version, debug);
  currentMode = ' ';
  if (gs1 == 1) {
    if (version < 100) {
      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 & 1) {
    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    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x4(%rbp),%r8d
mov    0x10(%rbp),%r9d
call   1060 <qr_define_mode@plt>
movb   $0x20,-0x39(%rbp)
cmpl   $0x1,-0x24(%rbp)
jne    11c9 <getBinaryLength+0x79>
cmpl   $0x64,-0x4(%rbp)
jge    11bb <getBinaryLength+0x6b>
mov    -0x40(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x40(%rbp)
jmp    11c4 <getBinaryLength+0x74>
mov    -0x40(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x40(%rbp)
jmp    11c9 <getBinaryLength+0x79>
cmpl   $0x0,-0x28(%rbp)
je     1222 <getBinaryLength+0xd2>
mov    -0x40(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x7f,-0x28(%rbp)
jg     11f4 <getBinaryLength+0xa4>
mov    -0x40(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x40(%rbp)
jmp    121d <getBinaryLength+0xcd>
cmpl   $0x3fff,-0x28(%rbp)
jg     120f <getBinaryLength+0xbf>
mov    -0x40(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x40(%rbp)
jmp    1218 <getBinaryLength+0xc8>
mov    -0x40(%rbp),%eax
add    $0x18,%eax
mov    %eax,-0x40(%rbp)
jmp    121d <getBinaryLength+0xcd>
jmp    1222 <getBinaryLength+0xd2>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    14e6 <getBinaryLength+0x396>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x39(%rbp),%ecx
cmp    %ecx,%eax
je     14d0 <getBinaryLength+0x380>
mov    -0x4(%rbp),%edi
call   1030 <mode_bits@plt>
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
call   1050 <cci_bits@plt>
mov    -0x58(%rbp),%rcx
add    %eax,%ecx
mov    -0x40(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1040 <blockLength@plt>
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0xd,%eax
ja     14c2 <getBinaryLength+0x372>
mov    -0x50(%rbp),%rax
lea    0xd45(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
imul   $0xd,-0x48(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    14c2 <getBinaryLength+0x372>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x48(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1335 <getBinaryLength+0x1e5>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
cmpl   $0xff,(%rax,%rcx,4)
jbe    1316 <getBinaryLength+0x1c6>
mov    -0x40(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x40(%rbp)
jmp    131f <getBinaryLength+0x1cf>
mov    -0x40(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x40(%rbp)
jmp    1324 <getBinaryLength+0x1d4>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12db <getBinaryLength+0x18b>
jmp    14c2 <getBinaryLength+0x372>
mov    -0x48(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     13a0 <getBinaryLength+0x250>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x48(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    139b <getBinaryLength+0x24b>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1385 <getBinaryLength+0x235>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    138a <getBinaryLength+0x23a>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1352 <getBinaryLength+0x202>
jmp    13a0 <getBinaryLength+0x250>
mov    -0x44(%rbp),%eax
mov    %eax,%edx
shr    $0x1f,%edx
mov    %eax,%ecx
add    %edx,%ecx
and    $0xfffffffe,%ecx
sub    %ecx,%eax
mov    %eax,-0x5c(%rbp)
je     13d0 <getBinaryLength+0x280>
jmp    13bf <getBinaryLength+0x26f>
mov    -0x5c(%rbp),%eax
sub    $0x1,%eax
je     13e9 <getBinaryLength+0x299>
jmp    1409 <getBinaryLength+0x2b9>
mov    -0x44(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
imul   $0xb,%eax,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1409 <getBinaryLength+0x2b9>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
imul   $0xb,%eax,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0x40(%rbp)
jmp    14c2 <getBinaryLength+0x372>
movslq -0x48(%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,-0x60(%rbp)
je     145f <getBinaryLength+0x30f>
jmp    143d <getBinaryLength+0x2ed>
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
je     1478 <getBinaryLength+0x328>
jmp    144e <getBinaryLength+0x2fe>
mov    -0x60(%rbp),%eax
sub    $0x2,%eax
je     149d <getBinaryLength+0x34d>
jmp    14bd <getBinaryLength+0x36d>
mov    -0x48(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    14bd <getBinaryLength+0x36d>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x40(%rbp)
jmp    14bd <getBinaryLength+0x36d>
mov    -0x48(%rbp),%eax
sub    $0x2,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0xa,%eax,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x40(%rbp)
jmp    14c2 <getBinaryLength+0x372>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
jmp    14d5 <getBinaryLength+0x385>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    122a <getBinaryLength+0xda>
mov    0x10(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     150e <getBinaryLength+0x3be>
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%r8d
lea    0xb2f(%rip),%rdi
call   1070 <printf@plt>
mov    -0x40(%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    $0x28,%rsp
mov    %r9d,%r14d
mov    %r8d,%ebx
mov    %rcx,%r13
mov    %rdx,%r15
mov    %edi,%ebp
mov    0x60(%rsp),%r9d
mov    %rsi,0x8(%rsp)
mov    %rsi,%rdi
mov    %rdx,%rsi
mov    %rcx,%rdx
mov    %r8d,%ecx
mov    %ebp,%r8d
call   1060 <qr_define_mode@plt>
xor    %eax,%eax
mov    %ebp,0x18(%rsp)
cmp    $0x64,%ebp
setl   %al
add    $0x3,%eax
xor    %r12d,%r12d
mov    %ebx,0x14(%rsp)
cmp    $0x1,%ebx
cmove  %eax,%r12d
test   %r14d,%r14d
je     11ba <getBinaryLength+0x6a>
cmp    $0x7f,%r14d
jg     16a6 <getBinaryLength+0x556>
add    $0xc,%r12d
mov    0x8(%rsp),%rbp
test   %r13,%r13
mov    %r14d,0x1c(%rsp)
je     1670 <getBinaryLength+0x520>
lea    0x30(%r15),%rbx
mov    $0x20,%cl
xor    %r14d,%r14d
jmp    1201 <getBinaryLength+0xb1>
lea    (%rax,%rax,2),%edx
lea    (%rax,%rdx,4),%eax
add    %eax,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x4,%rbx
cmp    %r13,%r14
je     1670 <getBinaryLength+0x520>
cmp    %cl,0x0(%rbp,%r14,1)
je     11f0 <getBinaryLength+0xa0>
mov    %rbx,0x20(%rsp)
mov    %r15,%rbx
mov    0x18(%rsp),%ebp
mov    %ebp,%edi
call   1030 <mode_bits@plt>
mov    %r13,%r15
mov    %rax,%r13
mov    0x8(%rsp),%rax
movsbl (%rax,%r14,1),%esi
mov    %ebp,%edi
call   1050 <cci_bits@plt>
add    %eax,%r13d
add    %r13d,%r12d
mov    %r15,%r13
mov    %r14,%rdi
mov    0x8(%rsp),%rsi
mov    %r15,%rdx
call   1040 <blockLength@plt>
mov    0x8(%rsp),%rbp
movsbl 0x0(%rbp,%r14,1),%ecx
mov    %ecx,%edx
add    $0xffffffbf,%edx
cmp    $0xd,%edx
ja     143b <getBinaryLength+0x2eb>
lea    0xde5(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
mov    %rbx,%r15
mov    0x20(%rsp),%rbx
movdqa 0xd7e(%rip),%xmm6
movdqa 0xd86(%rip),%xmm7
movdqa 0xd8d(%rip),%xmm8
movdqa 0xd94(%rip),%xmm9
movdqa 0xd9b(%rip),%xmm10
jmp    *%rdx
cmpl   $0x0,0x14(%rsp)
je     13a6 <getBinaryLength+0x256>
movslq %eax,%r9
lea    (%r14,%r9,1),%rdx
cmp    %rdx,%r14
jae    13a6 <getBinaryLength+0x256>
mov    %r14,%rsi
cmp    $0x8,%eax
jb     1390 <getBinaryLength+0x240>
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
movd   %eax,%xmm0
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     165b <getBinaryLength+0x50b>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm1,%xmm1
xor    %eax,%eax
xchg   %ax,%ax
movdqu -0x30(%rbx,%rax,4),%xmm2
movdqu -0x20(%rbx,%rax,4),%xmm3
movdqu -0x10(%rbx,%rax,4),%xmm4
movdqu (%rbx,%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    1300 <getBinaryLength+0x1b0>
test   $0x1,%r8b
je     1367 <getBinaryLength+0x217>
add    %r14,%rax
movdqu (%r15,%rax,4),%xmm2
movdqu 0x10(%r15,%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    %r9,%rsi
je     13a6 <getBinaryLength+0x256>
add    %r14,%rsi
nopl   0x0(%rax)
xor    %edi,%edi
cmpl   $0x25,(%r15,%rsi,4)
sete   %dil
add    %edi,%eax
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1390 <getBinaryLength+0x240>
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     1448 <getBinaryLength+0x2f8>
test   %esi,%esi
jne    11f0 <getBinaryLength+0xa0>
sar    %edx
lea    (%rdx,%rdx,4),%eax
lea    (%rdx,%rax,2),%eax
add    %r12d,%eax
mov    %eax,%r12d
jmp    11f0 <getBinaryLength+0xa0>
movslq %eax,%r9
lea    (%r14,%r9,1),%rdx
cmp    %rdx,%r14
jae    11f0 <getBinaryLength+0xa0>
cmp    $0x8,%eax
jae    1469 <getBinaryLength+0x319>
mov    %r14,%rax
jmp    15d0 <getBinaryLength+0x480>
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     15f4 <getBinaryLength+0x4a4>
cmp    $0x1,%esi
je     161d <getBinaryLength+0x4cd>
test   %esi,%esi
jne    11f0 <getBinaryLength+0xa0>
lea    (%rdx,%rdx,4),%eax
lea    (%r12,%rax,2),%r12d
jmp    11f0 <getBinaryLength+0xa0>
mov    %rbx,%r15
mov    0x20(%rsp),%rbx
jmp    11f0 <getBinaryLength+0xa0>
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,%r12d
add    $0x6,%r12d
jmp    11f0 <getBinaryLength+0xa0>
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
movd   %r12d,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1646 <getBinaryLength+0x4f6>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm3,%xmm3
xor    %edi,%edi
movdqa %xmm0,%xmm5
xchg   %ax,%ax
movdqu -0x30(%rbx,%rdi,4),%xmm4
movdqu -0x20(%rbx,%rdi,4),%xmm2
movdqu -0x10(%rbx,%rdi,4),%xmm0
movdqu (%rbx,%rdi,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,%rdi
movdqa %xmm0,%xmm5
movdqa %xmm1,%xmm3
add    $0xfffffffffffffffe,%rsi
jne    14a0 <getBinaryLength+0x350>
test   $0x1,%r8b
je     159d <getBinaryLength+0x44d>
add    %r14,%rdi
movdqu (%r15,%rdi,4),%xmm2
movdqu 0x10(%r15,%rdi,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,%r12d
cmp    %r9,%rax
je     11f0 <getBinaryLength+0xa0>
add    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %esi,%esi
cmpl   $0x100,(%r15,%rax,4)
setae  %sil
lea    (%r12,%rsi,8),%r12d
add    $0x8,%r12d
add    $0x1,%rax
cmp    %rax,%rdx
jne    15d0 <getBinaryLength+0x480>
jmp    11f0 <getBinaryLength+0xa0>
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    (%r12,%rax,2),%r12d
add    $0x7,%r12d
jmp    11f0 <getBinaryLength+0xa0>
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    (%r12,%rax,2),%r12d
add    $0x4,%r12d
jmp    11f0 <getBinaryLength+0xa0>
pxor   %xmm1,%xmm1
xor    %edi,%edi
test   $0x1,%r8b
jne    154f <getBinaryLength+0x3ff>
jmp    159d <getBinaryLength+0x44d>
pxor   %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%r8b
jne    1347 <getBinaryLength+0x1f7>
jmp    1367 <getBinaryLength+0x217>
mov    0x60(%rsp),%eax
test   $0x1,%al
je     1694 <getBinaryLength+0x544>
lea    0xa09(%rip),%rdi
mov    %r12d,%esi
mov    0x18(%rsp),%edx
mov    0x1c(%rsp),%ecx
mov    0x14(%rsp),%r8d
call   1070 <printf@plt>
mov    %r12d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x3fff,%r14d
mov    0x8(%rsp),%rbp
ja     16bd <getBinaryLength+0x56d>
add    $0x14,%r12d
jmp    11bf <getBinaryLength+0x6f>
add    $0x1c,%r12d
jmp    11bf <getBinaryLength+0x6f>

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, i64 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32*
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i64
%16 = alloca i64
%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 i64 %3, i64* %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 i64, i64* %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, i64 %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, 100
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 i64 0, i64* %15
br label %63
63: ; preds = %210, %62
%64 = load i64, i64* %15
%65 = load i64, i64* %11
%66 = icmp ult i64 %64, %65
br i1 %66, label %67, label %213
67: ; preds = %63
%68 = load i8*, i8** %9
%69 = load i64, i64* %15
%70 = getelementptr inbounds i8, i8* %68, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = load i8, i8* %17
%74 = sext i8 %73 to i32
%75 = icmp ne i32 %72, %74
br i1 %75, label %76, label %209
76: ; preds = %67
%77 = load i32, i32* %8
%78 = call i64 @mode_bits(i32 %77)
%79 = load i32, i32* %8
%80 = load i8*, i8** %9
%81 = load i64, i64* %15
%82 = getelementptr inbounds i8, i8* %80, i64 %81
%83 = load i8, i8* %82
%84 = call i64 @cci_bits(i32 %79, i8 signext %83)
%85 = add nsw i64 %78, %84
%86 = load i32, i32* %18
%87 = sext i32 %86 to i64
%88 = add nsw i64 %87, %85
%89 = trunc i64 %88 to i32
store i32 %89, i32* %18
%90 = load i64, i64* %15
%91 = load i8*, i8** %9
%92 = load i64, i64* %11
%93 = call i32 @blockLength(i64 %90, i8* %91, i64 %92)
store i32 %93, i32* %20
%94 = load i8*, i8** %9
%95 = load i64, i64* %15
%96 = getelementptr inbounds i8, i8* %94, i64 %95
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
switch i32 %98, label %204 [
i32 75, label %99
i32 66, label %104
i32 65, label %130
i32 78, label %176
]
99: ; preds = %76
%100 = load i32, i32* %20
%101 = mul nsw i32 %100, 13
%102 = load i32, i32* %18
%103 = add nsw i32 %102, %101
store i32 %103, i32* %18
br label %204
104: ; preds = %76
%105 = load i64, i64* %15
store i64 %105, i64* %16
br label %106
106: ; preds = %126, %104
%107 = load i64, i64* %16
%108 = load i64, i64* %15
%109 = load i32, i32* %20
%110 = sext i32 %109 to i64
%111 = add i64 %108, %110
%112 = icmp ult i64 %107, %111
br i1 %112, label %113, label %129
113: ; preds = %106
%114 = load i32*, i32** %10
%115 = load i64, i64* %16
%116 = getelementptr inbounds i32, i32* %114, i64 %115
%117 = load i32, i32* %116
%118 = icmp ugt i32 %117, 255
br i1 %118, label %119, label %122
119: ; preds = %113
%120 = load i32, i32* %18
%121 = add nsw i32 %120, 16
store i32 %121, i32* %18
br label %125
122: ; preds = %113
%123 = load i32, i32* %18
%124 = add nsw i32 %123, 8
store i32 %124, i32* %18
br label %125
125: ; preds = %122, %119
br label %126
126: ; preds = %125
%127 = load i64, i64* %16
%128 = add i64 %127, 1
store i64 %128, i64* %16
br label %106
129: ; preds = %106
br label %204
130: ; preds = %76
%131 = load i32, i32* %20
store i32 %131, i32* %19
%132 = load i32, i32* %12
%133 = icmp ne i32 %132, 0
br i1 %133, label %134, label %157
134: ; preds = %130
%135 = load i64, i64* %15
store i64 %135, i64* %16
br label %136
136: ; preds = %153, %134
%137 = load i64, i64* %16
%138 = load i64, i64* %15
%139 = load i32, i32* %20
%140 = sext i32 %139 to i64
%141 = add i64 %138, %140
%142 = icmp ult i64 %137, %141
br i1 %142, label %143, label %156
143: ; preds = %136
%144 = load i32*, i32** %10
%145 = load i64, i64* %16
%146 = getelementptr inbounds i32, i32* %144, i64 %145
%147 = load i32, i32* %146
%148 = icmp eq i32 %147, 37
br i1 %148, label %149, label %152
149: ; preds = %143
%150 = load i32, i32* %19
%151 = add nsw i32 %150, 1
store i32 %151, i32* %19
br label %152
152: ; preds = %149, %143
br label %153
153: ; preds = %152
%154 = load i64, i64* %16
%155 = add i64 %154, 1
store i64 %155, i64* %16
br label %136
156: ; preds = %136
br label %157
157: ; preds = %156, %130
%158 = load i32, i32* %19
%159 = srem i32 %158, 2
switch i32 %159, label %175 [
i32 0, label %160
i32 1, label %166
]
160: ; preds = %157
%161 = load i32, i32* %19
%162 = sdiv i32 %161, 2
%163 = mul nsw i32 %162, 11
%164 = load i32, i32* %18
%165 = add nsw i32 %164, %163
store i32 %165, i32* %18
br label %175
166: ; preds = %157
%167 = load i32, i32* %19
%168 = sub nsw i32 %167, 1
%169 = sdiv i32 %168, 2
%170 = mul nsw i32 %169, 11
%171 = load i32, i32* %18
%172 = add nsw i32 %171, %170
store i32 %172, i32* %18
%173 = load i32, i32* %18
%174 = add nsw i32 %173, 6
store i32 %174, i32* %18
br label %175
175: ; preds = %157, %166, %160
br label %204
176: ; preds = %76
%177 = load i32, i32* %20
%178 = srem i32 %177, 3
switch i32 %178, label %203 [
i32 0, label %179
i32 1, label %185
i32 2, label %194
]
179: ; preds = %176
%180 = load i32, i32* %20
%181 = sdiv i32 %180, 3
%182 = mul nsw i32 %181, 10
%183 = load i32, i32* %18
%184 = add nsw i32 %183, %182
store i32 %184, i32* %18
br label %203
185: ; preds = %176
%186 = load i32, i32* %20
%187 = sub nsw i32 %186, 1
%188 = sdiv i32 %187, 3
%189 = mul nsw i32 %188, 10
%190 = load i32, i32* %18
%191 = add nsw i32 %190, %189
store i32 %191, i32* %18
%192 = load i32, i32* %18
%193 = add nsw i32 %192, 4
store i32 %193, i32* %18
br label %203
194: ; preds = %176
%195 = load i32, i32* %20
%196 = sub nsw i32 %195, 2
%197 = sdiv i32 %196, 3
%198 = mul nsw i32 %197, 10
%199 = load i32, i32* %18
%200 = add nsw i32 %199, %198
store i32 %200, i32* %18
%201 = load i32, i32* %18
%202 = add nsw i32 %201, 7
store i32 %202, i32* %18
br label %203
203: ; preds = %176, %194, %185, %179
br label %204
204: ; preds = %76, %203, %175, %129, %99
%205 = load i8*, i8** %9
%206 = load i64, i64* %15
%207 = getelementptr inbounds i8, i8* %205, i64 %206
%208 = load i8, i8* %207
store i8 %208, i8* %17
br label %209
209: ; preds = %204, %67
br label %210
210: ; preds = %209
%211 = load i64, i64* %15
%212 = add i64 %211, 1
store i64 %212, i64* %15
br label %63
213: ; preds = %63
%214 = load i32, i32* %14
%215 = and i32 %214, 1
%216 = icmp ne i32 %215, 0
br i1 %216, label %217, label %223
217: ; preds = %213
%218 = load i32, i32* %18
%219 = load i32, i32* %8
%220 = load i32, i32* %13
%221 = load i32, i32* %12
%222 = call i32 @printf(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str, i64 0, i64 0), i32 %218, i32 %219, i32 %220, i32 %221)
br label %223
223: ; preds = %217, %213
%224 = load i32, i32* %18
ret i32 %224
}

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