#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ SEEK_END;
int /*<<< orphan*/ SEEK_SET;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int findIfBit(char *, int);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(char *, int, long, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(char *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int /*<<< orphan*/,
                         int /*<<< orphan*/);
long ftell(int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, long);
int /*<<< orphan*/ offBit(char *, int);
int /*<<< orphan*/ onBit(char *, int);
int /*<<< orphan*/ printf(char *, char *);
int main(int argc, char *argv[]) {
  long bufferSize = 0;
  char *inputBuffer;
  int inputIndex = 0;
  char *outputBuffer;
  int outputIndex = 0;
  char manipBuffer[5];
  int manipIndex = 0;
  char *fileToOpen;
  fileToOpen = argv[1] ? argv[1] : "pemerson";
  FILE *fileHandle = fopen(fileToOpen, "r");
  {
    fseek(fileHandle, 0, SEEK_SET);
    fseek(fileHandle, 0, SEEK_END);
    bufferSize = ftell(fileHandle);
    fseek(fileHandle, SEEK_SET, 0);
    inputBuffer = (char *)(malloc(sizeof(char) * bufferSize));
    memset(inputBuffer, 0, bufferSize);
    outputBuffer = (char *)(malloc(sizeof(char) * bufferSize));
    memset(outputBuffer, 0, bufferSize);
    fread(inputBuffer, sizeof(char), bufferSize, fileHandle);
  }
  fclose(fileHandle);
  printf("%s\n", inputBuffer);
  while (outputIndex < (bufferSize - 4)) {
    manipIndex = 0;
    manipBuffer[manipIndex++] = inputBuffer[inputIndex++];
    manipBuffer[manipIndex++] = inputBuffer[inputIndex++];
    manipBuffer[manipIndex++] = inputBuffer[inputIndex++];
    manipBuffer[manipIndex++] = inputBuffer[inputIndex++];
    outputBuffer[outputIndex++] = manipBuffer[0];
    outputBuffer[outputIndex++] = manipBuffer[3];
    outputBuffer[outputIndex++] = manipBuffer[2];
    outputBuffer[outputIndex++] = manipBuffer[1];
  }
  while (outputIndex < bufferSize) {
    outputBuffer[outputIndex++] = inputBuffer[inputIndex++];
  }
  for (int i = 0; i < bufferSize; i++) {
    if (outputBuffer[i] == 0) {
      continue;
    }
    int b2, b3, b4, b5;
    b2 = findIfBit(&outputBuffer[i], 2);
    b3 = findIfBit(&outputBuffer[i], 3);
    b4 = findIfBit(&outputBuffer[i], 4);
    b5 = findIfBit(&outputBuffer[i], 5);
    if (b2) {
      onBit(&outputBuffer[i], 4);
    } else {
      offBit(&outputBuffer[i], 4);
    }
    if (b4) {
      onBit(&outputBuffer[i], 2);
    } else {
      offBit(&outputBuffer[i], 2);
    }
    if (b5) {
      onBit(&outputBuffer[i], 3);
    } else {
      offBit(&outputBuffer[i], 3);
    }
    if (b3) {
      onBit(&outputBuffer[i], 5);
    } else {
      offBit(&outputBuffer[i], 5);
    }
  }
  for (int i = 0; i < bufferSize; i++) {
    if (i % 4 == 1 || i % 4 == 3) {
      outputBuffer[i] = (outputBuffer[i] ^ 'm');
    }
  }
  printf("%s\n", outputBuffer);
  free(outputBuffer);
  free(inputBuffer);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
cmpq   $0x0,0x8(%rax)
je     1213 <main+0x53>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x70(%rbp)
jmp    1223 <main+0x63>
lea    0xde6(%rip),%rax
mov    %rax,-0x70(%rbp)
jmp    1223 <main+0x63>
mov    -0x70(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rdi
lea    0xdd3(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    0x2d8e(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   10d0 <fseek@plt>
mov    -0x50(%rbp),%rdi
mov    0x2d8a(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   10d0 <fseek@plt>
mov    -0x50(%rbp),%rdi
call   10a0 <ftell@plt>
mov    %rax,-0x18(%rbp)
mov    -0x50(%rbp),%rdi
mov    0x2d59(%rip),%rax
mov    (%rax),%esi
xor    %edx,%edx
call   10d0 <fseek@plt>
mov    -0x18(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x18(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   10c0 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    $0x1,%esi
call   1040 <fread@plt>
mov    -0x50(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x20(%rbp),%rsi
lea    0xd15(%rip),%rdi
call   1070 <printf@plt>
movslq -0x34(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x4,%rcx
cmp    %rcx,%rax
jge    1414 <main+0x254>
movl   $0x0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %cl,-0x39(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %cl,-0x39(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %cl,-0x39(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %cl,-0x39(%rbp,%rax,1)
mov    -0x39(%rbp),%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x36(%rbp),%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x37(%rbp),%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    12fb <main+0x13b>
jmp    1419 <main+0x259>
movslq -0x34(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1456 <main+0x296>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1419 <main+0x259>
movl   $0x0,-0x54(%rbp)
movslq -0x54(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    15dc <main+0x41c>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1485 <main+0x2c5>
jmp    15ce <main+0x40e>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x2,%esi
call   10b0 <findIfBit@plt>
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x3,%esi
call   10b0 <findIfBit@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x4,%esi
call   10b0 <findIfBit@plt>
mov    %eax,-0x60(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x5,%esi
call   10b0 <findIfBit@plt>
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x58(%rbp)
je     1509 <main+0x349>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x4,%esi
call   1060 <onBit@plt>
jmp    151e <main+0x35e>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x4,%esi
call   1090 <offBit@plt>
cmpl   $0x0,-0x60(%rbp)
je     1542 <main+0x382>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x2,%esi
call   1060 <onBit@plt>
jmp    1557 <main+0x397>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x2,%esi
call   1090 <offBit@plt>
cmpl   $0x0,-0x64(%rbp)
je     157b <main+0x3bb>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x3,%esi
call   1060 <onBit@plt>
jmp    1590 <main+0x3d0>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x3,%esi
call   1090 <offBit@plt>
cmpl   $0x0,-0x5c(%rbp)
je     15b4 <main+0x3f4>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x5,%esi
call   1060 <onBit@plt>
jmp    15c9 <main+0x409>
mov    -0x30(%rbp),%rdi
movslq -0x54(%rbp),%rax
add    %rax,%rdi
mov    $0x5,%esi
call   1090 <offBit@plt>
jmp    15ce <main+0x40e>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    145d <main+0x29d>
movl   $0x0,-0x68(%rbp)
movslq -0x68(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    1648 <main+0x488>
mov    -0x68(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
je     1619 <main+0x459>
mov    -0x68(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
jne    1635 <main+0x475>
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
xor    $0x6d,%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    163a <main+0x47a>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    15e3 <main+0x423>
mov    -0x30(%rbp),%rsi
lea    0x9b8(%rip),%rdi
call   1070 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    0x8(%rsi),%rax
test   %rax,%rax
lea    0xe24(%rip),%rdi
cmovne %rax,%rdi
lea    0xe22(%rip),%rsi
call   10e0 <fopen@plt>
mov    %rax,%rbx
mov    0x2de2(%rip),%r14
mov    (%r14),%edx
xor    %ebp,%ebp
mov    %rax,%rdi
xor    %esi,%esi
call   10d0 <fseek@plt>
mov    0x2ddc(%rip),%rax
mov    (%rax),%edx
mov    %rbx,%rdi
xor    %esi,%esi
call   10d0 <fseek@plt>
mov    %rbx,%rdi
call   10a0 <ftell@plt>
mov    %rax,%r12
mov    (%r14),%esi
mov    %rbx,%rdi
xor    %edx,%edx
call   10d0 <fseek@plt>
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1080 <memset@plt>
mov    %r12d,%edi
call   10c0 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1080 <memset@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %r12,%rdx
mov    %rbx,%rcx
call   1040 <fread@plt>
mov    %rbx,%rdi
call   1050 <fclose@plt>
lea    0xd87(%rip),%rdi
mov    %r14,%rsi
call   1070 <printf@plt>
cmp    $0x5,%r12
jl     12d4 <main+0x114>
lea    -0x4(%r12),%rdi
xor    %ebp,%ebp
mov    0x8(%rsp),%rsi
xchg   %ax,%ax
movzbl (%r14,%rbp,1),%ecx
movzbl 0x1(%r14,%rbp,1),%edx
movzbl 0x2(%r14,%rbp,1),%ebx
movzbl 0x3(%r14,%rbp,1),%eax
mov    %cl,(%rsi,%rbp,1)
mov    %al,0x1(%rsi,%rbp,1)
mov    %bl,0x2(%rsi,%rbp,1)
mov    %dl,0x3(%rsi,%rbp,1)
add    $0x4,%rbp
cmp    %rbp,%rdi
jg     12a0 <main+0xe0>
and    $0xfffffffc,%ebp
jmp    12d9 <main+0x119>
mov    0x8(%rsp),%rsi
mov    %r12,%r11
sub    %rbp,%r11
jle    1413 <main+0x253>
cmp    $0x8,%r11
jb     13f5 <main+0x235>
lea    (%rsi,%rbp,1),%r10
lea    (%r14,%rbp,1),%r9
lea    (%r14,%r12,1),%rcx
cmp    %rcx,%r10
jae    130d <main+0x14d>
lea    (%rsi,%r12,1),%rcx
cmp    %rcx,%r9
jb     13f5 <main+0x235>
cmp    $0x20,%r11
jae    131a <main+0x15a>
xor    %eax,%eax
jmp    13b8 <main+0x1f8>
mov    %r11,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     13e8 <main+0x228>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rsi,%rbp,1),%rdx
add    $0x30,%rdx
lea    (%r14,%rbp,1),%rcx
add    $0x30,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rcx,%rbx,1),%xmm0
movups -0x20(%rcx,%rbx,1),%xmm1
movups %xmm0,-0x30(%rdx,%rbx,1)
movups %xmm1,-0x20(%rdx,%rbx,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x40,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1360 <main+0x1a0>
test   $0x1,%r8b
je     13ad <main+0x1ed>
add    %rbp,%rbx
movups (%r14,%rbx,1),%xmm0
movups 0x10(%r14,%rbx,1),%xmm1
movups %xmm0,(%rsi,%rbx,1)
movups %xmm1,0x10(%rsi,%rbx,1)
cmp    %rax,%r11
je     1413 <main+0x253>
test   $0x18,%r11b
je     13f2 <main+0x232>
mov    %r11,%rcx
and    $0xfffffffffffffff8,%rcx
add    %rcx,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r9,%rax,1),%rdx
mov    %rdx,(%r10,%rax,1)
add    $0x8,%rax
cmp    %rax,%rcx
jne    13d0 <main+0x210>
cmp    %rcx,%r11
jne    13f5 <main+0x235>
jmp    1413 <main+0x253>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    1396 <main+0x1d6>
jmp    13ad <main+0x1ed>
add    %rax,%rbp
mov    %r14,%rax
add    %rbp,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
mov    %cl,(%rsi,%rbp,1)
add    $0x1,%rbp
add    $0x1,%rax
cmp    %rbp,%r12
jg     1400 <main+0x240>
test   %r12,%r12
jle    1551 <main+0x391>
mov    %r14,0x10(%rsp)
xor    %r13d,%r13d
jmp    1447 <main+0x287>
cs nopw 0x0(%rax,%rax,1)
call   1090 <offBit@plt>
mov    0x8(%rsp),%rsi
add    $0x1,%r13
cmp    %r13,%r12
je     1513 <main+0x353>
cmpb   $0x0,(%rsi,%r13,1)
je     143a <main+0x27a>
lea    (%rsi,%r13,1),%rbx
mov    %rbx,%rdi
mov    $0x2,%esi
call   10b0 <findIfBit@plt>
mov    %eax,%r15d
mov    %rbx,%rdi
mov    $0x3,%esi
call   10b0 <findIfBit@plt>
mov    %eax,0x4(%rsp)
mov    %rbx,%rdi
mov    $0x4,%esi
call   10b0 <findIfBit@plt>
mov    %eax,%r14d
mov    %rbx,%rdi
mov    $0x5,%esi
call   10b0 <findIfBit@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
mov    $0x4,%esi
test   %r15d,%r15d
je     14b0 <main+0x2f0>
call   1060 <onBit@plt>
jmp    14b5 <main+0x2f5>
cs nopw 0x0(%rax,%rax,1)
call   1090 <offBit@plt>
mov    %rbx,%rdi
mov    $0x2,%esi
test   %r14d,%r14d
je     14d0 <main+0x310>
call   1060 <onBit@plt>
jmp    14d5 <main+0x315>
nopl   0x0(%rax)
call   1090 <offBit@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
test   %ebp,%ebp
je     14f0 <main+0x330>
call   1060 <onBit@plt>
jmp    14f5 <main+0x335>
nopl   0x0(%rax,%rax,1)
call   1090 <offBit@plt>
mov    0x4(%rsp),%eax
mov    %rbx,%rdi
mov    $0x5,%esi
test   %eax,%eax
je     1430 <main+0x270>
call   1060 <onBit@plt>
jmp    1435 <main+0x275>
test   %r12,%r12
mov    0x10(%rsp),%r14
jle    1551 <main+0x391>
cmp    $0x1,%r12
jne    1527 <main+0x367>
xor    %eax,%eax
jmp    153e <main+0x37e>
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
xorb   $0x6d,0x1(%rsi,%rax,1)
add    $0x2,%rax
cmp    %rax,%rcx
jne    1530 <main+0x370>
test   $0x1,%r12b
je     1551 <main+0x391>
mov    %eax,%ecx
not    %ecx
test   $0x1,%cl
jne    1551 <main+0x391>
xorb   $0x6d,(%rsi,%rax,1)
lea    0xab3(%rip),%rdi
mov    %rsi,%rbx
call   1070 <printf@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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