#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 EOF;
int /*<<< orphan*/ clock();
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int fgetc(int /*<<< orphan*/ *);
scalar_t__ fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ fputc(int, int /*<<< orphan*/ *);
int rand();
int /*<<< orphan*/ srand(int /*<<< orphan*/);
int /*<<< orphan*/ stderr;
int main(int argc, char **argv) {
  int c;
  FILE *inputFile;
  FILE *outputFile;
  char uppercase[256];
  char lowercase[256];
  char dna[4] = {'A', 'C', 'G', 'T'};
  if (argc != 3 && argc != 4) {
    fprintf(stderr, "%s <input> <output>\n", argv[0]);
    fprintf(stderr, "%s <input> <output> a\n", argv[0]);
    fprintf(stderr, "%s <input> <output> n\n", argv[0]);
    fprintf(stderr, "%s <input> <output> r\n", argv[0]);
    return 1;
  }
  inputFile = (FILE *)fopen(argv[1], "r");
  if (inputFile == NULL) {
    fprintf(stderr, "Input file not exists!\n");
    return 1;
  }
  outputFile = (FILE *)fopen(argv[2], "r");
  if (outputFile != NULL) {
    fprintf(stderr, "Output file exists!\n");
    return 1;
  }
  outputFile = (FILE *)fopen(argv[2], "wb");
  srand(clock());
  for (c = 0; c < 256; c++) {
    uppercase[c] = (char)c;
  }
  for (c = 'a'; c <= 'z'; c++) {
    uppercase[c] = (char)c + 'A' - 'a';
  }
  for (c = 0; c < 256; c++) {
    lowercase[c] = (char)c;
  }
  for (c = 'A'; c <= 'Z'; c++) {
    lowercase[c] = (char)c + 'a' - 'A';
  }
  c = fgetc(inputFile);
  while (c == '\n' || c == '\r') {
    c = fgetc(inputFile);
  }
  while (c == '>') {
    while (c != '\n' && c != '\r' && c != EOF) {
      c = fgetc(inputFile);
    }
    while (c == '\n' || c == '\r') {
      c = fgetc(inputFile);
    }
  }
  while (c != EOF) {
    if (argc == 4 || (c != 'n' && c != 'N')) {
      if ((c == 'n' || c == 'N') && (argc == 4 && argv[3][0] == 'a')) {
        if (c == 'n') {
          fputc('a', outputFile);
        } else {
          fputc('A', outputFile);
        }
      } else {
        if ((c == 'n' || c == 'N') && (argc == 4 && argv[3][0] == 'r')) {
          if (c == 'n') {
            fputc(lowercase[dna[rand() % 4]], outputFile);
          } else {
            fputc(uppercase[dna[rand() % 4]], outputFile);
          }
        } else {
          fputc(c, outputFile);
        }
      }
    }
    c = fgetc(inputFile);
    while (c == '\n' || c == '\r') {
      c = fgetc(inputFile);
    }
    while (c == '>') {
      while (c != '\n' && c != '\r' && c != EOF) {
        c = fgetc(inputFile);
      }
      while (c == '\n' || c == '\r') {
        c = fgetc(inputFile);
      }
    }
  }
  fclose(inputFile);
  fclose(outputFile);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xe61(%rip),%eax
mov    %eax,-0x234(%rbp)
cmpl   $0x3,-0x8(%rbp)
je     123d <main+0xbd>
cmpl   $0x4,-0x8(%rbp)
je     123d <main+0xbd>
mov    0x2e18(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe34(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2dfa(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe2b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2ddc(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe24(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2dbe(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe1d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    173f <main+0x5bf>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe12(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1283 <main+0x103>
mov    0x2d71(%rip),%rax
mov    (%rax),%edi
lea    0xdf0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    173f <main+0x5bf>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0xdcc(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     12c9 <main+0x149>
mov    0x2d2b(%rip),%rax
mov    (%rax),%edi
lea    0xdc2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    173f <main+0x5bf>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0xdb5(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x28(%rbp)
mov    $0x0,%al
call   1030 <clock@plt>
mov    %eax,%edi
call   1070 <srand@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x100,-0x14(%rbp)
jge    1321 <main+0x1a1>
mov    -0x14(%rbp),%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12f6 <main+0x176>
movl   $0x61,-0x14(%rbp)
cmpl   $0x7a,-0x14(%rbp)
jg     1359 <main+0x1d9>
mov    -0x14(%rbp),%eax
movsbl %al,%eax
add    $0x41,%eax
sub    $0x61,%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1328 <main+0x1a8>
movl   $0x0,-0x14(%rbp)
cmpl   $0x100,-0x14(%rbp)
jge    138b <main+0x20b>
mov    -0x14(%rbp),%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x230(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1360 <main+0x1e0>
movl   $0x41,-0x14(%rbp)
cmpl   $0x5a,-0x14(%rbp)
jg     13c3 <main+0x243>
mov    -0x14(%rbp),%eax
movsbl %al,%eax
add    $0x61,%eax
sub    $0x41,%eax
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x230(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1392 <main+0x212>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
mov    $0x1,%al
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x235(%rbp)
je     13ee <main+0x26e>
cmpl   $0xd,-0x14(%rbp)
sete   %al
mov    %al,-0x235(%rbp)
mov    -0x235(%rbp),%al
test   $0x1,%al
jne    1401 <main+0x281>
jmp    1412 <main+0x292>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    13cf <main+0x24f>
jmp    1417 <main+0x297>
cmpl   $0x3e,-0x14(%rbp)
jne    14d0 <main+0x350>
jmp    1426 <main+0x2a6>
xor    %eax,%eax
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x236(%rbp)
je     145f <main+0x2df>
xor    %eax,%eax
cmpl   $0xd,-0x14(%rbp)
mov    %al,-0x236(%rbp)
je     145f <main+0x2df>
mov    -0x14(%rbp),%eax
mov    0x2b94(%rip),%rcx
cmp    (%rcx),%eax
setne  %al
mov    %al,-0x236(%rbp)
mov    -0x236(%rbp),%al
test   $0x1,%al
jne    1472 <main+0x2f2>
jmp    1483 <main+0x303>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    1426 <main+0x2a6>
jmp    1488 <main+0x308>
mov    $0x1,%al
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x237(%rbp)
je     14a7 <main+0x327>
cmpl   $0xd,-0x14(%rbp)
sete   %al
mov    %al,-0x237(%rbp)
mov    -0x237(%rbp),%al
test   $0x1,%al
jne    14ba <main+0x33a>
jmp    14cb <main+0x34b>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    1488 <main+0x308>
jmp    1417 <main+0x297>
jmp    14d5 <main+0x355>
mov    -0x14(%rbp),%eax
mov    0x2b09(%rip),%rcx
cmp    (%rcx),%eax
je     172d <main+0x5ad>
cmpl   $0x4,-0x8(%rbp)
je     1505 <main+0x385>
cmpl   $0x6e,-0x14(%rbp)
je     161b <main+0x49b>
cmpl   $0x4e,-0x14(%rbp)
je     161b <main+0x49b>
cmpl   $0x6e,-0x14(%rbp)
je     1519 <main+0x399>
cmpl   $0x4e,-0x14(%rbp)
jne    1567 <main+0x3e7>
cmpl   $0x4,-0x8(%rbp)
jne    1567 <main+0x3e7>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
cmp    $0x61,%eax
jne    1567 <main+0x3e7>
cmpl   $0x6e,-0x14(%rbp)
jne    1554 <main+0x3d4>
mov    -0x28(%rbp),%rsi
mov    $0x61,%edi
call   1060 <fputc@plt>
jmp    1562 <main+0x3e2>
mov    -0x28(%rbp),%rsi
mov    $0x41,%edi
call   1060 <fputc@plt>
jmp    1616 <main+0x496>
cmpl   $0x6e,-0x14(%rbp)
je     157b <main+0x3fb>
cmpl   $0x4e,-0x14(%rbp)
jne    1605 <main+0x485>
cmpl   $0x4,-0x8(%rbp)
jne    1605 <main+0x485>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
cmp    $0x72,%eax
jne    1605 <main+0x485>
cmpl   $0x6e,-0x14(%rbp)
jne    15d4 <main+0x454>
mov    $0x0,%al
call   10a0 <rand@plt>
mov    $0x4,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
movsbq -0x234(%rbp,%rax,1),%rax
ff ff
movsbl -0x230(%rbp,%rax,1),%edi
ff
mov    -0x28(%rbp),%rsi
call   1060 <fputc@plt>
jmp    1600 <main+0x480>
mov    $0x0,%al
call   10a0 <rand@plt>
mov    $0x4,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
movsbq -0x234(%rbp,%rax,1),%rax
ff ff
movsbl -0x130(%rbp,%rax,1),%edi
ff
mov    -0x28(%rbp),%rsi
call   1060 <fputc@plt>
jmp    1611 <main+0x491>
mov    -0x14(%rbp),%edi
mov    -0x28(%rbp),%rsi
call   1060 <fputc@plt>
jmp    1616 <main+0x496>
jmp    161b <main+0x49b>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
mov    $0x1,%al
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x238(%rbp)
je     1646 <main+0x4c6>
cmpl   $0xd,-0x14(%rbp)
sete   %al
mov    %al,-0x238(%rbp)
mov    -0x238(%rbp),%al
test   $0x1,%al
jne    1659 <main+0x4d9>
jmp    166a <main+0x4ea>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    1627 <main+0x4a7>
jmp    166f <main+0x4ef>
cmpl   $0x3e,-0x14(%rbp)
jne    1728 <main+0x5a8>
jmp    167e <main+0x4fe>
xor    %eax,%eax
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x239(%rbp)
je     16b7 <main+0x537>
xor    %eax,%eax
cmpl   $0xd,-0x14(%rbp)
mov    %al,-0x239(%rbp)
je     16b7 <main+0x537>
mov    -0x14(%rbp),%eax
mov    0x293c(%rip),%rcx
cmp    (%rcx),%eax
setne  %al
mov    %al,-0x239(%rbp)
mov    -0x239(%rbp),%al
test   $0x1,%al
jne    16ca <main+0x54a>
jmp    16db <main+0x55b>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    167e <main+0x4fe>
jmp    16e0 <main+0x560>
mov    $0x1,%al
cmpl   $0xa,-0x14(%rbp)
mov    %al,-0x23a(%rbp)
je     16ff <main+0x57f>
cmpl   $0xd,-0x14(%rbp)
sete   %al
mov    %al,-0x23a(%rbp)
mov    -0x23a(%rbp),%al
test   $0x1,%al
jne    1712 <main+0x592>
jmp    1723 <main+0x5a3>
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %eax,-0x14(%rbp)
jmp    16e0 <main+0x560>
jmp    166f <main+0x4ef>
jmp    14d5 <main+0x355>
mov    -0x20(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x28(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x4(%rbp),%eax
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %rsi,%r15
mov    %edi,%r14d
lea    -0x5(%r14),%eax
cmp    $0xfffffffd,%eax
ja     11fd <main+0x7d>
mov    0x2e31(%rip),%rbx
mov    (%rbx),%edi
mov    (%r15),%rdx
lea    0xf71(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%rbx),%edi
mov    (%r15),%rdx
lea    0xf73(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%rbx),%edi
mov    (%r15),%rdx
lea    0xf77(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%rbx),%edi
mov    (%r15),%rdx
lea    0xf7b(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%eax
jmp    15f7 <main+0x477>
mov    0x8(%r15),%rdi
lea    0xf76(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     123c <main+0xbc>
mov    %rax,%rbx
mov    0x10(%r15),%rdi
lea    0xf5e(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     125d <main+0xdd>
mov    0x2da7(%rip),%rax
mov    (%rax),%edi
lea    0xf5e(%rip),%rsi
jmp    124c <main+0xcc>
mov    0x2d95(%rip),%rax
mov    (%rax),%edi
lea    0xf34(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%eax
jmp    15f7 <main+0x477>
mov    0x10(%r15),%rdi
lea    0xf45(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,0x8(%rsp)
xor    %eax,%eax
call   1030 <clock@plt>
mov    %eax,%edi
call   1070 <srand@plt>
movaps 0xd79(%rip),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0xd7a(%rip),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0xd7a(%rip),%xmm10
movaps %xmm10,0x130(%rsp)
movaps 0xd79(%rip),%xmm11
movaps %xmm11,0x140(%rsp)
movaps 0xd78(%rip),%xmm12
movaps %xmm12,0x150(%rsp)
movaps 0xd77(%rip),%xmm13
movaps %xmm13,0x160(%rsp)
movaps 0xd76(%rip),%xmm14
movaps %xmm14,0x170(%rsp)
movaps 0xd75(%rip),%xmm15
movaps %xmm15,0x180(%rsp)
movaps 0xd74(%rip),%xmm9
movaps %xmm9,0x190(%rsp)
movaps 0xd74(%rip),%xmm1
movaps %xmm1,0x1a0(%rsp)
movaps 0xd75(%rip),%xmm2
movaps %xmm2,0x1b0(%rsp)
movaps 0xd76(%rip),%xmm3
movaps %xmm3,0x1c0(%rsp)
movaps 0xd77(%rip),%xmm4
movaps %xmm4,0x1d0(%rsp)
movaps 0xd78(%rip),%xmm5
movaps %xmm5,0x1e0(%rsp)
movaps 0xd79(%rip),%xmm6
movaps %xmm6,0x1f0(%rsp)
movaps 0xd7a(%rip),%xmm7
movaps %xmm7,0x200(%rsp)
movaps 0xd7a(%rip),%xmm8
movups %xmm8,0x171(%rsp)
movaps 0xc6a(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xc6e(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps %xmm10,0x30(%rsp)
movaps %xmm11,0x40(%rsp)
movaps %xmm12,0x50(%rsp)
movaps %xmm13,0x60(%rsp)
movaps %xmm14,0x70(%rsp)
movaps %xmm15,0x80(%rsp)
movaps %xmm9,0x90(%rsp)
movaps %xmm1,0xa0(%rsp)
movaps %xmm2,0xb0(%rsp)
movaps %xmm3,0xc0(%rsp)
movaps %xmm4,0xd0(%rsp)
movaps %xmm5,0xe0(%rsp)
movaps %xmm6,0xf0(%rsp)
movaps %xmm7,0x100(%rsp)
movaps 0xcfa(%rip),%xmm0
movups %xmm0,0x51(%rsp)
movabs $0x5857565554535251,%rax
56 57 58
mov    %rax,0x181(%rsp)
movw   $0x5a59,0x189(%rsp)
movabs $0x7877767574737271,%rax
76 77 78
mov    %rax,0x61(%rsp)
movw   $0x7a79,0x69(%rsp)
nopl   (%rax)
mov    %rbx,%rdi
call   1050 <fgetc@plt>
cmp    $0xa,%eax
je     1450 <main+0x2d0>
mov    %eax,%ebp
cmp    $0xd,%eax
je     1450 <main+0x2d0>
cmp    $0x3e,%ebp
jne    14b9 <main+0x339>
mov    $0x3e,%ebp
mov    0x2b73(%rip),%r12
cmp    $0xa,%ebp
je     14aa <main+0x32a>
cmp    $0xd,%ebp
je     14aa <main+0x32a>
cmp    (%r12),%ebp
je     14aa <main+0x32a>
mov    %rbx,%rdi
call   1050 <fgetc@plt>
mov    %eax,%ebp
jmp    1475 <main+0x2f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1050 <fgetc@plt>
mov    %eax,%ebp
cmp    $0xa,%ebp
je     14a0 <main+0x320>
cmp    $0xd,%ebp
je     14a0 <main+0x320>
cmp    $0x3e,%ebp
je     1475 <main+0x2f5>
mov    0x2b28(%rip),%r13
cmp    0x0(%r13),%ebp
je     15e3 <main+0x463>
cmp    $0x4,%r14d
setne  %r12b
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,%eax
and    $0xffffffdf,%eax
cmp    $0x4e,%eax
sete   %cl
test   %r12b,%cl
jne    1570 <main+0x3f0>
cmp    $0x4,%r14d
jne    1560 <main+0x3e0>
cmp    $0x4e,%eax
jne    1560 <main+0x3e0>
mov    0x18(%r15),%rax
mov    (%rax),%al
cmp    $0x72,%al
je     151f <main+0x39f>
cmp    $0x61,%al
jne    1560 <main+0x3e0>
xor    %eax,%eax
cmp    $0x6e,%ebp
sete   %al
shl    $0x5,%eax
or     $0x41,%eax
mov    %eax,%ebp
jmp    1560 <main+0x3e0>
xor    %eax,%eax
call   10a0 <rand@plt>
lea    0x3(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffffc,%ecx
sub    %ecx,%eax
cltq
lea    0xbe4(%rip),%rcx
movsbq (%rax,%rcx,1),%rax
cmp    $0x6e,%ebp
jne    154d <main+0x3cd>
movsbl 0x10(%rsp,%rax,1),%ebp
jmp    1560 <main+0x3e0>
movsbl 0x110(%rsp,%rax,1),%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,%edi
mov    0x8(%rsp),%rsi
call   1060 <fputc@plt>
nopl   0x0(%rax)
mov    %rbx,%rdi
call   1050 <fgetc@plt>
cmp    $0xa,%eax
je     1570 <main+0x3f0>
mov    %eax,%ebp
cmp    $0xd,%eax
je     1570 <main+0x3f0>
jmp    15d4 <main+0x454>
cs nopw 0x0(%rax,%rax,1)
cmp    $0xa,%ebp
je     15ca <main+0x44a>
cmp    $0xd,%ebp
je     15ca <main+0x44a>
cmp    0x0(%r13),%ebp
je     15ca <main+0x44a>
mov    %rbx,%rdi
call   1050 <fgetc@plt>
mov    %eax,%ebp
cmp    $0xa,%ebp
jne    1595 <main+0x415>
jmp    15ca <main+0x44a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1050 <fgetc@plt>
mov    %eax,%ebp
cmp    $0xa,%ebp
je     15c0 <main+0x440>
cmp    $0xd,%ebp
je     15c0 <main+0x440>
cmp    $0x3e,%ebp
je     1590 <main+0x410>
cmp    0x0(%r13),%ebp
jne    14e0 <main+0x360>
mov    %rbx,%rdi
call   1040 <fclose@plt>
mov    0x8(%rsp),%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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