#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*/ diff_full;
typedef int /*<<< orphan*/ diff;
typedef int /*<<< orphan*/ byte_value;
typedef int /*<<< orphan*/ byte_name;
typedef int /*<<< orphan*/ byte_grp;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int EOF;
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ memset(char *, char, int);
int /*<<< orphan*/ printf(char *, ...);
int sprintf(char *, char *, unsigned char);
int main(int argc, char **argv) {
  char cmd1_bit[1024];
  char cmd2_bit[1024];
  char diff[1024];
  char diff_full[1024];
  char byte_grp[1024];
  char byte_name[1024];
  char byte_value[1024];
  unsigned char byte_val;
  int c, c1num, c2num, i, sim, n, fn;
  int byte_num, bit_num;
  FILE *fcmd1, *fcmd2;
  if (argc < 3) {
    printf("usage: %s cmd_1 cmd_2\n", argv[0]);
    exit(0);
  }
  fn = 1;
  memset(diff_full, ' ', sizeof(diff_full));
  do {
    fcmd1 = fopen(argv[fn++], "r");
    fcmd2 = fopen(argv[fn], "r");
    if (fcmd1 == NULL || fcmd2 == NULL) {
      fclose(fcmd1);
      fclose(fcmd2);
      printf("File error\n");
      return -1;
    }
    c1num = 0;
    while ((c = fgetc(fcmd1)) != EOF && c != '\n') {
      cmd1_bit[c1num++] = c;
    }
    c2num = 0;
    while ((c = fgetc(fcmd2)) != EOF && c != '\n') {
      cmd2_bit[c2num++] = c;
    }
    sim = 1;
    if (c1num != c2num) {
      printf("Commannd not similar %i!=%i\n", c1num, c2num);
      sim = 0;
    }
    for (i = 0; i != c1num; i++) {
      if (cmd1_bit[i] == '[' && cmd2_bit[i] != '[') {
        sim = 0;
        printf("Commannd not similar bit %i\n", i);
        break;
      }
      if (cmd2_bit[i] == '[' && cmd1_bit[i] != '[') {
        sim = 0;
        printf("Commannd not similar bit %i\n", i);
        break;
      }
      if (cmd1_bit[i] == ']' && cmd2_bit[i] != ']') {
        sim = 0;
        printf("Commannd not similar bit %i\n", i);
        break;
      }
      if (cmd2_bit[i] == ']' && cmd1_bit[i] != ']') {
        sim = 0;
        printf("Commannd not similar bit %i\n", i);
        break;
      }
    }
    if (sim == 0)
      return -1;
    memset(diff, ' ', sizeof(diff));
    for (i = 0; i != c1num; i++) {
      if (cmd1_bit[i] != cmd2_bit[i]) {
        diff[i] = '*';
        diff_full[i] = '*';
      }
    }
    memset(byte_grp, ' ', sizeof(byte_grp));
    memset(byte_name, ' ', sizeof(byte_name));
    memset(byte_value, ' ', sizeof(byte_value));
    for (i = 0; i != c1num; i++) {
      printf("%c", cmd1_bit[i]);
    }
    printf(" <- %s\n", argv[fn - 1]);
    for (i = 0; i != c2num; i++) {
      printf("%c", cmd2_bit[i]);
    }
    printf(" <- %s\n", argv[fn]);
    for (i = 0; i != c1num; i++) {
      printf("%c", diff[i]);
    }
    printf("\n");
  } while (fn + 1 != argc);
  byte_num = 0;
  bit_num = 0;
  for (i = 0; i != c1num; i++) {
    if (cmd1_bit[i] == '[' || cmd1_bit[i] == ']') {
      if (cmd1_bit[i] == ']') {
        n = sprintf(byte_value + i - bit_num - 1, "| 0x%X", byte_val);
        byte_value[i + n - bit_num - 1] = ' ';
        byte_value[i] = '|';
        byte_grp[i] = '|';
        byte_name[i] = '|';
      }
      byte_num = 0;
      bit_num = -1;
      byte_val = 0;
    } else {
      if (cmd1_bit[i] == '0' || cmd1_bit[i] == '1') {
        bit_num = (bit_num + 1) % 8;
        if (bit_num == 0) {
          byte_grp[i] = '|';
          n = sprintf(byte_name + i, "| B %i", byte_num);
          byte_name[i + n] = ' ';
          if (byte_num != 0) {
            n = sprintf(byte_value + i - 8, "| 0x%X", byte_val);
            byte_value[i + n - 8] = ' ';
          }
          byte_val = 0;
          byte_num++;
        } else {
          byte_grp[i] = '0' + bit_num;
        }
        if (cmd1_bit[i] == '1' && diff_full[i] != '*') {
          byte_val |= 0x01 << bit_num;
        }
      }
    }
  }
  for (i = 0; i != c1num; i++) {
    printf("%c", diff_full[i]);
  }
  printf("\n");
  for (i = 0; i != c1num; i++) {
    printf("%c", byte_grp[i]);
  }
  printf("\n");
  for (i = 0; i != c1num; i++) {
    printf("%c", byte_name[i]);
  }
  printf("\n");
  for (i = 0; i != c1num; i++) {
    printf("%c", byte_value[i]);
  }
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c50,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x3,-0x8(%rbp)
jge    11af <main+0x3f>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe5f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %edi,%edi
call   1090 <exit@plt>
movl   $0x1,-0x1c30(%rbp)
lea    -0x1010(%rbp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
mov    -0x10(%rbp),%rax
mov    -0x1c30(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c30(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe25(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x1c40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xe03(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x1c48(%rbp)
cmpq   $0x0,-0x1c40(%rbp)
je     123c <main+0xcc>
cmpq   $0x0,-0x1c48(%rbp)
jne    126e <main+0xfe>
mov    -0x1c40(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x1c48(%rbp),%rdi
call   1030 <fclose@plt>
lea    0xdbe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1b8f <main+0xa1f>
movl   $0x0,-0x1c1c(%rbp)
mov    -0x1c40(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,%ecx
mov    %ecx,-0x1c18(%rbp)
xor    %eax,%eax
mov    0x2d53(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x1c49(%rbp)
je     12b3 <main+0x143>
cmpl   $0xa,-0x1c18(%rbp)
setne  %al
mov    %al,-0x1c49(%rbp)
mov    -0x1c49(%rbp),%al
test   $0x1,%al
jne    12c6 <main+0x156>
jmp    12ed <main+0x17d>
mov    -0x1c18(%rbp),%eax
mov    %al,%cl
mov    -0x1c1c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1c1c(%rbp)
cltq
mov    %cl,-0x410(%rbp,%rax,1)
jmp    1278 <main+0x108>
movl   $0x0,-0x1c20(%rbp)
mov    -0x1c48(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,%ecx
mov    %ecx,-0x1c18(%rbp)
xor    %eax,%eax
mov    0x2cd4(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x1c4a(%rbp)
je     1332 <main+0x1c2>
cmpl   $0xa,-0x1c18(%rbp)
setne  %al
mov    %al,-0x1c4a(%rbp)
mov    -0x1c4a(%rbp),%al
test   $0x1,%al
jne    1345 <main+0x1d5>
jmp    136c <main+0x1fc>
mov    -0x1c18(%rbp),%eax
mov    %al,%cl
mov    -0x1c20(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1c20(%rbp)
cltq
mov    %cl,-0x810(%rbp,%rax,1)
jmp    12f7 <main+0x187>
movl   $0x1,-0x1c28(%rbp)
mov    -0x1c1c(%rbp),%eax
cmp    -0x1c20(%rbp),%eax
je     13ac <main+0x23c>
mov    -0x1c1c(%rbp),%esi
mov    -0x1c20(%rbp),%edx
lea    0xc8a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c28(%rbp)
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     152d <main+0x3bd>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
jne    141b <main+0x2ab>
movslq -0x1c24(%rbp),%rax
movsbl -0x810(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
je     141b <main+0x2ab>
movl   $0x0,-0x1c28(%rbp)
mov    -0x1c24(%rbp),%esi
lea    0xc33(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    152d <main+0x3bd>
movslq -0x1c24(%rbp),%rax
movsbl -0x810(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
jne    146e <main+0x2fe>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
je     146e <main+0x2fe>
movl   $0x0,-0x1c28(%rbp)
mov    -0x1c24(%rbp),%esi
lea    0xbe0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    152d <main+0x3bd>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
jne    14c1 <main+0x351>
movslq -0x1c24(%rbp),%rax
movsbl -0x810(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
je     14c1 <main+0x351>
movl   $0x0,-0x1c28(%rbp)
mov    -0x1c24(%rbp),%esi
lea    0xb8d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    152d <main+0x3bd>
movslq -0x1c24(%rbp),%rax
movsbl -0x810(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
jne    1514 <main+0x3a4>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
je     1514 <main+0x3a4>
movl   $0x0,-0x1c28(%rbp)
mov    -0x1c24(%rbp),%esi
lea    0xb3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    152d <main+0x3bd>
jmp    1519 <main+0x3a9>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    13b6 <main+0x246>
cmpl   $0x0,-0x1c28(%rbp)
jne    1546 <main+0x3d6>
movl   $0xffffffff,-0x4(%rbp)
jmp    1b8f <main+0xa1f>
lea    -0xc10(%rbp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     15d5 <main+0x465>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
movslq -0x1c24(%rbp),%rcx
movsbl -0x810(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     15bc <main+0x44c>
movslq -0x1c24(%rbp),%rax
movb   $0x2a,-0xc10(%rbp,%rax,1)
2a
movslq -0x1c24(%rbp),%rax
movb   $0x2a,-0x1010(%rbp,%rax,1)
2a
jmp    15c1 <main+0x451>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1566 <main+0x3f6>
lea    -0x1410(%rbp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
lea    -0x1810(%rbp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
lea    -0x1c10(%rbp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1050 <memset@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1664 <main+0x4f4>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%esi
ff
lea    0xa16(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1621 <main+0x4b1>
mov    -0x10(%rbp),%rax
mov    -0x1c30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x9e3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c20(%rbp),%eax
je     16d3 <main+0x563>
movslq -0x1c24(%rbp),%rax
movsbl -0x810(%rbp,%rax,1),%esi
ff
lea    0x9a7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1690 <main+0x520>
mov    -0x10(%rbp),%rax
movslq -0x1c30(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x979(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     173d <main+0x5cd>
movslq -0x1c24(%rbp),%rax
movsbl -0xc10(%rbp,%rax,1),%esi
ff
lea    0x93d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    16fa <main+0x58a>
lea    0x8d1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c30(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jne    11cf <main+0x5f>
movl   $0x0,-0x1c34(%rbp)
movl   $0x0,-0x1c38(%rbp)
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1a1c <main+0x8ac>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5b,%eax
je     17bd <main+0x64d>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
jne    187e <main+0x70e>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x5d,%eax
jne    185e <main+0x6ee>
lea    -0x1c10(%rbp),%rdi
movslq -0x1c24(%rbp),%rax
add    %rax,%rdi
movslq -0x1c38(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
add    $0xffffffffffffffff,%rdi
lea    0x86a(%rip),%rsi
movzbl -0x1c11(%rbp),%edx
call   1080 <sprintf@plt>
mov    %eax,-0x1c2c(%rbp)
mov    -0x1c24(%rbp),%eax
add    -0x1c2c(%rbp),%eax
sub    -0x1c38(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x20,-0x1c10(%rbp,%rax,1)
20
movslq -0x1c24(%rbp),%rax
movb   $0x7c,-0x1c10(%rbp,%rax,1)
7c
movslq -0x1c24(%rbp),%rax
movb   $0x7c,-0x1410(%rbp,%rax,1)
7c
movslq -0x1c24(%rbp),%rax
movb   $0x7c,-0x1810(%rbp,%rax,1)
7c
movl   $0x0,-0x1c34(%rbp)
movl   $0xffffffff,-0x1c38(%rbp)
ff ff ff
movb   $0x0,-0x1c11(%rbp)
jmp    1a03 <main+0x893>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
je     18ae <main+0x73e>
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    19fe <main+0x88e>
mov    -0x1c38(%rbp),%eax
add    $0x1,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1c38(%rbp)
cmpl   $0x0,-0x1c38(%rbp)
jne    1992 <main+0x822>
movslq -0x1c24(%rbp),%rax
movb   $0x7c,-0x1410(%rbp,%rax,1)
7c
lea    -0x1810(%rbp),%rdi
movslq -0x1c24(%rbp),%rax
add    %rax,%rdi
mov    -0x1c34(%rbp),%eax
lea    0x772(%rip),%rsi
movzbl %al,%edx
call   1080 <sprintf@plt>
mov    %eax,-0x1c2c(%rbp)
mov    -0x1c24(%rbp),%eax
add    -0x1c2c(%rbp),%eax
cltq
movb   $0x20,-0x1810(%rbp,%rax,1)
20
cmpl   $0x0,-0x1c34(%rbp)
je     1977 <main+0x807>
lea    -0x1c10(%rbp),%rdi
movslq -0x1c24(%rbp),%rax
add    %rax,%rdi
add    $0xfffffffffffffff8,%rdi
lea    0x71e(%rip),%rsi
movzbl -0x1c11(%rbp),%edx
call   1080 <sprintf@plt>
mov    %eax,-0x1c2c(%rbp)
mov    -0x1c24(%rbp),%eax
add    -0x1c2c(%rbp),%eax
sub    $0x8,%eax
cltq
movb   $0x20,-0x1c10(%rbp,%rax,1)
20
movb   $0x0,-0x1c11(%rbp)
mov    -0x1c34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c34(%rbp)
jmp    19ab <main+0x83b>
mov    -0x1c38(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x1c24(%rbp),%rax
mov    %cl,-0x1410(%rbp,%rax,1)
movslq -0x1c24(%rbp),%rax
movsbl -0x410(%rbp,%rax,1),%eax
ff
cmp    $0x31,%eax
jne    19f9 <main+0x889>
movslq -0x1c24(%rbp),%rax
movsbl -0x1010(%rbp,%rax,1),%eax
ff
cmp    $0x2a,%eax
je     19f9 <main+0x889>
mov    -0x1c38(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
movzbl -0x1c11(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x1c11(%rbp)
jmp    19fe <main+0x88e>
jmp    1a03 <main+0x893>
jmp    1a08 <main+0x898>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    177b <main+0x60b>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1a69 <main+0x8f9>
movslq -0x1c24(%rbp),%rax
movsbl -0x1010(%rbp,%rax,1),%esi
ff
lea    0x611(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1a26 <main+0x8b6>
lea    0x5a5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1ac4 <main+0x954>
movslq -0x1c24(%rbp),%rax
movsbl -0x1410(%rbp,%rax,1),%esi
ff
lea    0x5b6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1a81 <main+0x911>
lea    0x54a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1b1f <main+0x9af>
movslq -0x1c24(%rbp),%rax
movsbl -0x1810(%rbp,%rax,1),%esi
ff
lea    0x55b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1adc <main+0x96c>
lea    0x4ef(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x1c24(%rbp)
mov    -0x1c24(%rbp),%eax
cmp    -0x1c1c(%rbp),%eax
je     1b7a <main+0xa0a>
movslq -0x1c24(%rbp),%rax
movsbl -0x1c10(%rbp,%rax,1),%esi
ff
lea    0x500(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x1c24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c24(%rbp)
jmp    1b37 <main+0x9c7>
lea    0x494(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1c50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c28,%rsp
mov    %rsi,%r12
cmp    $0x2,%edi
jle    17cd <main+0x63d>
mov    %edi,%ebx
lea    0x820(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
mov    %ebx,%eax
mov    %rax,0x18(%rsp)
mov    $0x1,%r14d
lea    0xe96(%rip),%rax
mov    0x2e07(%rip),%r13
mov    %r12,0x8(%rsp)
mov    %r14,%r15
mov    (%r12,%r14,8),%rdi
mov    %rax,%rbx
mov    %rax,%rsi
call   1090 <fopen@plt>
mov    %rax,%rbp
mov    0x8(%r12,%r14,8),%rdi
mov    %rbx,%rsi
call   1090 <fopen@plt>
mov    %rax,%rbx
test   %rbp,%rbp
je     1583 <main+0x3f3>
test   %rbx,%rbx
je     1583 <main+0x3f3>
mov    %rbp,%rdi
call   1080 <fgetc@plt>
xor    %r12d,%r12d
mov    $0x0,%r14d
cmp    $0xa,%eax
je     126f <main+0xdf>
mov    $0x0,%r14d
cmp    0x0(%r13),%eax
je     126f <main+0xdf>
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %al,0x420(%rsp,%r14,1)
add    $0x1,%r14
mov    %rbp,%rdi
call   1080 <fgetc@plt>
cmp    $0xa,%eax
je     126f <main+0xdf>
cmp    0x0(%r13),%eax
jne    1250 <main+0xc0>
mov    %rbx,%rdi
call   1080 <fgetc@plt>
cmp    $0xa,%eax
je     12af <main+0x11f>
cmp    0x0(%r13),%eax
je     12af <main+0x11f>
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %al,0x1020(%rsp,%r12,1)
add    $0x1,%r12
mov    %rbx,%rdi
call   1080 <fgetc@plt>
cmp    $0xa,%eax
je     12af <main+0x11f>
cmp    0x0(%r13),%eax
jne    1290 <main+0x100>
mov    %r14d,%ebx
cmp    %r12d,%ebx
jne    12e0 <main+0x150>
test   %rbx,%rbx
jne    12fc <main+0x16c>
lea    0xc20(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
mov    $0x1,%bpl
jmp    13a2 <main+0x212>
nopl   0x0(%rax,%rax,1)
lea    0xd30(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1060 <printf@plt>
test   %rbx,%rbx
je     156c <main+0x3dc>
xor    %esi,%esi
jmp    1311 <main+0x181>
cmp    $0x5b,%al
jne    155e <main+0x3ce>
add    $0x1,%rsi
cmp    %rsi,%rbx
je     1350 <main+0x1c0>
movzbl 0x420(%rsp,%rsi,1),%ecx
movzbl 0x1020(%rsp,%rsi,1),%eax
cmp    $0x5b,%cl
je     1300 <main+0x170>
cmp    $0x5b,%al
je     155e <main+0x3ce>
cmp    $0x5d,%cl
jne    1340 <main+0x1b0>
cmp    $0x5d,%al
je     1308 <main+0x178>
jmp    155e <main+0x3ce>
nopl   0x0(%rax)
cmp    $0x5d,%al
jne    1308 <main+0x178>
jmp    155e <main+0x3ce>
nopl   0x0(%rax)
cmp    %r12d,%ebx
jne    156c <main+0x3dc>
lea    0xc20(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
cmp    $0x1,%ebx
jne    1496 <main+0x306>
xor    %eax,%eax
test   $0x1,%bl
je     13a0 <main+0x210>
mov    0x420(%rsp,%rax,1),%cl
cmp    0x1020(%rsp,%rax,1),%cl
je     13a0 <main+0x210>
movb   $0x2a,0xc20(%rsp,%rax,1)
2a
movb   $0x2a,0x820(%rsp,%rax,1)
2a
xor    %ebp,%ebp
lea    0x1(%r15),%r14
lea    0x1820(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
lea    0x1420(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
lea    0x20(%rsp),%rdi
mov    $0x20,%esi
mov    $0x400,%edx
call   1070 <memset@plt>
test   %bpl,%bpl
je     1410 <main+0x280>
mov    0x8(%rsp),%r12
mov    (%r12,%r15,8),%rsi
lea    0xc54(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    145b <main+0x2cb>
nopl   0x0(%rax)
mov    %ebp,0x14(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsbl 0x420(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1420 <main+0x290>
mov    0x8(%rsp),%r12
mov    (%r12,%r15,8),%rsi
lea    0xc0b(%rip),%rbp
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmpb   $0x0,0x14(%rsp)
je     14f1 <main+0x361>
mov    (%r12,%r14,8),%rsi
mov    %rbp,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x1,%bpl
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x2,%r15
cmp    0x18(%rsp),%r15
mov    0x8(%rsp),%r12
lea    0xbe5(%rip),%rax
jne    11e6 <main+0x56>
jmp    15a1 <main+0x411>
mov    %ebx,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
jmp    14ad <main+0x31d>
nop
add    $0x2,%rax
cmp    %rax,%rcx
je     137b <main+0x1eb>
movzbl 0x420(%rsp,%rax,1),%edx
cmp    0x1020(%rsp,%rax,1),%dl
je     14ce <main+0x33e>
movb   $0x2a,0xc20(%rsp,%rax,1)
2a
movb   $0x2a,0x820(%rsp,%rax,1)
2a
movzbl 0x421(%rsp,%rax,1),%edx
cmp    0x1021(%rsp,%rax,1),%dl
je     14a0 <main+0x310>
movb   $0x2a,0xc21(%rsp,%rax,1)
2a
movb   $0x2a,0x821(%rsp,%rax,1)
2a
jmp    14a0 <main+0x310>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl 0x1020(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1500 <main+0x370>
mov    0x8(%rsp),%rax
mov    (%rax,%r14,8),%rsi
lea    0xb2b(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x1,%bpl
mov    0x14(%rsp),%r12d
test   %r12b,%r12b
jne    146c <main+0x2dc>
xor    %ebp,%ebp
movsbl 0xc20(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1540 <main+0x3b0>
mov    %r12d,%ebp
jmp    146c <main+0x2dc>
lea    0xacf(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xffffffff,%eax
add    $0x1c28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbp,%rdi
call   1050 <fclose@plt>
mov    %rbx,%rdi
call   1050 <fclose@plt>
lea    0xacd(%rip),%rdi
call   1040 <puts@plt>
jmp    156c <main+0x3dc>
test   %bpl,%bpl
je     15b5 <main+0x425>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    177f <main+0x5ef>
mov    %bpl,0x8(%rsp)
xor    %ebp,%ebp
xor    %r13d,%r13d
xor    %r14d,%r14d
jmp    15dd <main+0x44d>
mov    $0xffffffff,%r13d
xor    %r14d,%r14d
xor    %r15d,%r15d
add    $0x1,%rbp
cmp    %rbp,%rbx
je     16fe <main+0x56e>
movzbl 0x420(%rsp,%rbp,1),%r12d
lea    -0x30(%r12),%eax
cmp    $0x2,%al
jb     1642 <main+0x4b2>
cmp    $0x5b,%r12b
je     15c4 <main+0x434>
cmp    $0x5d,%r12b
jne    15d0 <main+0x440>
movslq %r13d,%r14
mov    %rbp,%rax
sub    %r14,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x1f,%rdi
movzbl %r15b,%edx
lea    0xa42(%rip),%rsi
call   10a0 <sprintf@plt>
sub    %r14d,%eax
add    %ebp,%eax
add    $0xffffffff,%eax
cltq
movb   $0x20,0x20(%rsp,%rax,1)
movb   $0x7c,0x20(%rsp,%rbp,1)
movb   $0x7c,0x1820(%rsp,%rbp,1)
7c
movb   $0x7c,0x1420(%rsp,%rbp,1)
7c
jmp    15c4 <main+0x434>
lea    0x1(%r13),%eax
add    $0x8,%r13d
test   %eax,%eax
cmovns %eax,%r13d
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
mov    %eax,%r13d
sub    %ecx,%r13d
je     1675 <main+0x4e5>
lea    0x30(%r13),%eax
mov    %al,0x1820(%rsp,%rbp,1)
cmp    $0x31,%r12b
jne    15d0 <main+0x440>
jmp    16de <main+0x54e>
movb   $0x7c,0x1820(%rsp,%rbp,1)
7c
lea    (%rsp,%rbp,1),%rdi
add    $0x1420,%rdi
movzbl %r14b,%edx
lea    0x9cd(%rip),%rsi
call   10a0 <sprintf@plt>
add    %ebp,%eax
cltq
movb   $0x20,0x1420(%rsp,%rax,1)
20
test   %r14d,%r14d
je     16cd <main+0x53d>
lea    (%rsp,%rbp,1),%rdi
add    $0x18,%rdi
movzbl %r15b,%edx
lea    0x99d(%rip),%rsi
call   10a0 <sprintf@plt>
add    %ebp,%eax
add    $0xfffffff8,%eax
cltq
movb   $0x20,0x20(%rsp,%rax,1)
add    $0x1,%r14d
xor    %r15d,%r15d
cmp    $0x31,%r12b
jne    15d0 <main+0x440>
cmpb   $0x2a,0x820(%rsp,%rbp,1)
2a
je     15d0 <main+0x440>
mov    $0x1,%eax
mov    %r13d,%ecx
shl    %cl,%eax
or     %al,%r15b
jmp    15d0 <main+0x440>
cmpb   $0x0,0x8(%rsp)
jne    1726 <main+0x596>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsbl 0x820(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1710 <main+0x580>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %rbx,%rbx
je     177f <main+0x5ef>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsbl 0x1820(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1740 <main+0x5b0>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %rbx,%rbx
je     1795 <main+0x605>
xor    %ebp,%ebp
movsbl 0x1420(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1767 <main+0x5d7>
jmp    1797 <main+0x607>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    17bc <main+0x62c>
xor    %ebx,%ebx
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %ebx,%ebx
je     17bc <main+0x62c>
mov    %ebx,%ebx
xor    %ebp,%ebp
movsbl 0x20(%rsp,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    17a9 <main+0x619>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
jmp    1571 <main+0x3e1>
mov    (%r12),%rsi
lea    0x828(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %edi,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@.str = [23 x i8] c"usage: %s cmd_1 cmd_2\0A\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [12 x i8] c"File error\0A\00"
@EOF = global i32 0
@.str.3 = [29 x i8] c"Commannd not similar %i!=%i\0A\00"
@.str.4 = [29 x i8] c"Commannd not similar bit %i\0A\00"
@.str.5 = [3 x i8] c"%c\00"
@.str.6 = [8 x i8] c" <- %s\0A\00"
@.str.7 = [2 x i8] c"\0A\00"
@.str.8 = [7 x i8] c"| 0x%X\00"
@.str.9 = [7 x i8] c"| B %i\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [1024 x i8]
%7 = alloca [1024 x i8]
%8 = alloca [1024 x i8]
%9 = alloca [1024 x i8]
%10 = alloca [1024 x i8]
%11 = alloca [1024 x i8]
%12 = alloca [1024 x i8]
%13 = alloca i8
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca i32*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%25 = load i32, i32* %4
%26 = icmp slt i32 %25, 3
br i1 %26, label %27, label %33
27: ; preds = %2
%28 = load i8**, i8*** %5
%29 = getelementptr inbounds i8*, i8** %28, i64 0
%30 = load i8*, i8** %29
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0), i8* %30)
%32 = call i32 @exit(i32 0)
unreachable
33: ; preds = %2
store i32 1, i32* %20
%34 = getelementptr inbounds [1024 x i8], [1024 x i8]* %9, i64 0, i64 0
%35 = call i32 @memset(i8* %34, i8 signext 32, i32 1024)
br label %36
36: ; preds = %282, %33
%37 = load i8**, i8*** %5
%38 = load i32, i32* %20
%39 = add nsw i32 %38, 1
store i32 %39, i32* %20
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds i8*, i8** %37, i64 %40
%42 = load i8*, i8** %41
%43 = call i32* @fopen(i8* %42, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %43, i32** %23
%44 = load i8**, i8*** %5
%45 = load i32, i32* %20
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8*, i8** %44, i64 %46
%48 = load i8*, i8** %47
%49 = call i32* @fopen(i8* %48, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %49, i32** %24
%50 = load i32*, i32** %23
%51 = icmp eq i32* %50, null
br i1 %51, label %55, label %52
52: ; preds = %36
%53 = load i32*, i32** %24
%54 = icmp eq i32* %53, null
br i1 %54, label %55, label %61
55: ; preds = %52, %36
%56 = load i32*, i32** %23
%57 = call i32 @fclose(i32* %56)
%58 = load i32*, i32** %24
%59 = call i32 @fclose(i32* %58)
%60 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
store i32 -1, i32* %3
br label %497
61: ; preds = %52
store i32 0, i32* %15
br label %62
62: ; preds = %72, %61
%63 = load i32*, i32** %23
%64 = call i32 @fgetc(i32* %63)
store i32 %64, i32* %14
%65 = load i32, i32* @EOF
%66 = icmp ne i32 %64, %65
br i1 %66, label %67, label %70
67: ; preds = %62
%68 = load i32, i32* %14
%69 = icmp ne i32 %68, 10
br label %70
70: ; preds = %67, %62
%71 = phi i1 [ false, %62 ], [ %69, %67 ]
br i1 %71, label %72, label %79
72: ; preds = %70
%73 = load i32, i32* %14
%74 = trunc i32 %73 to i8
%75 = load i32, i32* %15
%76 = add nsw i32 %75, 1
store i32 %76, i32* %15
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %77
store i8 %74, i8* %78
br label %62
79: ; preds = %70
store i32 0, i32* %16
br label %80
80: ; preds = %90, %79
%81 = load i32*, i32** %24
%82 = call i32 @fgetc(i32* %81)
store i32 %82, i32* %14
%83 = load i32, i32* @EOF
%84 = icmp ne i32 %82, %83
br i1 %84, label %85, label %88
85: ; preds = %80
%86 = load i32, i32* %14
%87 = icmp ne i32 %86, 10
br label %88
88: ; preds = %85, %80
%89 = phi i1 [ false, %80 ], [ %87, %85 ]
br i1 %89, label %90, label %97
90: ; preds = %88
%91 = load i32, i32* %14
%92 = trunc i32 %91 to i8
%93 = load i32, i32* %16
%94 = add nsw i32 %93, 1
store i32 %94, i32* %16
%95 = sext i32 %93 to i64
%96 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %95
store i8 %92, i8* %96
br label %80
97: ; preds = %88
store i32 1, i32* %18
%98 = load i32, i32* %15
%99 = load i32, i32* %16
%100 = icmp ne i32 %98, %99
br i1 %100, label %101, label %105
101: ; preds = %97
%102 = load i32, i32* %15
%103 = load i32, i32* %16
%104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i32 %102, i32 %103)
store i32 0, i32* %18
br label %105
105: ; preds = %101, %97
store i32 0, i32* %17
br label %106
106: ; preds = %179, %105
%107 = load i32, i32* %17
%108 = load i32, i32* %15
%109 = icmp ne i32 %107, %108
br i1 %109, label %110, label %182
110: ; preds = %106
%111 = load i32, i32* %17
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %112
%114 = load i8, i8* %113
%115 = sext i8 %114 to i32
%116 = icmp eq i32 %115, 91
br i1 %116, label %117, label %127
117: ; preds = %110
%118 = load i32, i32* %17
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %119
%121 = load i8, i8* %120
%122 = sext i8 %121 to i32
%123 = icmp ne i32 %122, 91
br i1 %123, label %124, label %127
124: ; preds = %117
store i32 0, i32* %18
%125 = load i32, i32* %17
%126 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), i32 %125)
br label %182
127: ; preds = %117, %110
%128 = load i32, i32* %17
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %129
%131 = load i8, i8* %130
%132 = sext i8 %131 to i32
%133 = icmp eq i32 %132, 91
br i1 %133, label %134, label %144
134: ; preds = %127
%135 = load i32, i32* %17
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %136
%138 = load i8, i8* %137
%139 = sext i8 %138 to i32
%140 = icmp ne i32 %139, 91
br i1 %140, label %141, label %144
141: ; preds = %134
store i32 0, i32* %18
%142 = load i32, i32* %17
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), i32 %142)
br label %182
144: ; preds = %134, %127
%145 = load i32, i32* %17
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %146
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = icmp eq i32 %149, 93
br i1 %150, label %151, label %161
151: ; preds = %144
%152 = load i32, i32* %17
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = icmp ne i32 %156, 93
br i1 %157, label %158, label %161
158: ; preds = %151
store i32 0, i32* %18
%159 = load i32, i32* %17
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), i32 %159)
br label %182
161: ; preds = %151, %144
%162 = load i32, i32* %17
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %163
%165 = load i8, i8* %164
%166 = sext i8 %165 to i32
%167 = icmp eq i32 %166, 93
br i1 %167, label %168, label %178
168: ; preds = %161
%169 = load i32, i32* %17
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %170
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp ne i32 %173, 93
br i1 %174, label %175, label %178
175: ; preds = %168
store i32 0, i32* %18
%176 = load i32, i32* %17
%177 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), i32 %176)
br label %182
178: ; preds = %168, %161
br label %179
179: ; preds = %178
%180 = load i32, i32* %17
%181 = add nsw i32 %180, 1
store i32 %181, i32* %17
br label %106
182: ; preds = %175, %158, %141, %124, %106
%183 = load i32, i32* %18
%184 = icmp eq i32 %183, 0
br i1 %184, label %185, label %186
185: ; preds = %182
store i32 -1, i32* %3
br label %497
186: ; preds = %182
%187 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 0
%188 = call i32 @memset(i8* %187, i8 signext 32, i32 1024)
store i32 0, i32* %17
br label %189
189: ; preds = %213, %186
%190 = load i32, i32* %17
%191 = load i32, i32* %15
%192 = icmp ne i32 %190, %191
br i1 %192, label %193, label %216
193: ; preds = %189
%194 = load i32, i32* %17
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %195
%197 = load i8, i8* %196
%198 = sext i8 %197 to i32
%199 = load i32, i32* %17
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %200
%202 = load i8, i8* %201
%203 = sext i8 %202 to i32
%204 = icmp ne i32 %198, %203
br i1 %204, label %205, label %212
205: ; preds = %193
%206 = load i32, i32* %17
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %207
store i8 42, i8* %208
%209 = load i32, i32* %17
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [1024 x i8], [1024 x i8]* %9, i64 0, i64 %210
store i8 42, i8* %211
br label %212
212: ; preds = %205, %193
br label %213
213: ; preds = %212
%214 = load i32, i32* %17
%215 = add nsw i32 %214, 1
store i32 %215, i32* %17
br label %189
216: ; preds = %189
%217 = getelementptr inbounds [1024 x i8], [1024 x i8]* %10, i64 0, i64 0
%218 = call i32 @memset(i8* %217, i8 signext 32, i32 1024)
%219 = getelementptr inbounds [1024 x i8], [1024 x i8]* %11, i64 0, i64 0
%220 = call i32 @memset(i8* %219, i8 signext 32, i32 1024)
%221 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 0
%222 = call i32 @memset(i8* %221, i8 signext 32, i32 1024)
store i32 0, i32* %17
br label %223
223: ; preds = %234, %216
%224 = load i32, i32* %17
%225 = load i32, i32* %15
%226 = icmp ne i32 %224, %225
br i1 %226, label %227, label %237
227: ; preds = %223
%228 = load i32, i32* %17
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %229
%231 = load i8, i8* %230
%232 = sext i8 %231 to i32
%233 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %232)
br label %234
234: ; preds = %227
%235 = load i32, i32* %17
%236 = add nsw i32 %235, 1
store i32 %236, i32* %17
br label %223
237: ; preds = %223
%238 = load i8**, i8*** %5
%239 = load i32, i32* %20
%240 = sub nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i8*, i8** %238, i64 %241
%243 = load i8*, i8** %242
%244 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* %243)
store i32 0, i32* %17
br label %245
245: ; preds = %256, %237
%246 = load i32, i32* %17
%247 = load i32, i32* %16
%248 = icmp ne i32 %246, %247
br i1 %248, label %249, label %259
249: ; preds = %245
%250 = load i32, i32* %17
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %251
%253 = load i8, i8* %252
%254 = sext i8 %253 to i32
%255 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %254)
br label %256
256: ; preds = %249
%257 = load i32, i32* %17
%258 = add nsw i32 %257, 1
store i32 %258, i32* %17
br label %245
259: ; preds = %245
%260 = load i8**, i8*** %5
%261 = load i32, i32* %20
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i8*, i8** %260, i64 %262
%264 = load i8*, i8** %263
%265 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* %264)
store i32 0, i32* %17
br label %266
266: ; preds = %277, %259
%267 = load i32, i32* %17
%268 = load i32, i32* %15
%269 = icmp ne i32 %267, %268
br i1 %269, label %270, label %280
270: ; preds = %266
%271 = load i32, i32* %17
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %272
%274 = load i8, i8* %273
%275 = sext i8 %274 to i32
%276 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %275)
br label %277
277: ; preds = %270
%278 = load i32, i32* %17
%279 = add nsw i32 %278, 1
store i32 %279, i32* %17
br label %266
280: ; preds = %266
%281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %282
282: ; preds = %280
%283 = load i32, i32* %20
%284 = add nsw i32 %283, 1
%285 = load i32, i32* %4
%286 = icmp ne i32 %284, %285
br i1 %286, label %36, label %287
287: ; preds = %282
store i32 0, i32* %21
store i32 0, i32* %22
store i32 0, i32* %17
br label %288
288: ; preds = %429, %287
%289 = load i32, i32* %17
%290 = load i32, i32* %15
%291 = icmp ne i32 %289, %290
br i1 %291, label %292, label %432
292: ; preds = %288
%293 = load i32, i32* %17
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %294
%296 = load i8, i8* %295
%297 = sext i8 %296 to i32
%298 = icmp eq i32 %297, 91
br i1 %298, label %306, label %299
299: ; preds = %292
%300 = load i32, i32* %17
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %301
%303 = load i8, i8* %302
%304 = sext i8 %303 to i32
%305 = icmp eq i32 %304, 93
br i1 %305, label %306, label %343
306: ; preds = %299, %292
%307 = load i32, i32* %17
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %308
%310 = load i8, i8* %309
%311 = sext i8 %310 to i32
%312 = icmp eq i32 %311, 93
br i1 %312, label %313, label %342
313: ; preds = %306
%314 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 0
%315 = load i32, i32* %17
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i8, i8* %314, i64 %316
%318 = load i32, i32* %22
%319 = sext i32 %318 to i64
%320 = sub i64 0, %319
%321 = getelementptr inbounds i8, i8* %317, i64 %320
%322 = getelementptr inbounds i8, i8* %321, i64 -1
%323 = load i8, i8* %13
%324 = call i32 @sprintf(i8* %322, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8 zeroext %323)
store i32 %324, i32* %19
%325 = load i32, i32* %17
%326 = load i32, i32* %19
%327 = add nsw i32 %325, %326
%328 = load i32, i32* %22
%329 = sub nsw i32 %327, %328
%330 = sub nsw i32 %329, 1
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 %331
store i8 32, i8* %332
%333 = load i32, i32* %17
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 %334
store i8 124, i8* %335
%336 = load i32, i32* %17
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [1024 x i8], [1024 x i8]* %10, i64 0, i64 %337
store i8 124, i8* %338
%339 = load i32, i32* %17
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds [1024 x i8], [1024 x i8]* %11, i64 0, i64 %340
store i8 124, i8* %341
br label %342
342: ; preds = %313, %306
store i32 0, i32* %21
store i32 -1, i32* %22
store i8 0, i8* %13
br label %428
343: ; preds = %299
%344 = load i32, i32* %17
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %345
%347 = load i8, i8* %346
%348 = sext i8 %347 to i32
%349 = icmp eq i32 %348, 48
br i1 %349, label %357, label %350
350: ; preds = %343
%351 = load i32, i32* %17
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %352
%354 = load i8, i8* %353
%355 = sext i8 %354 to i32
%356 = icmp eq i32 %355, 49
br i1 %356, label %357, label %427
357: ; preds = %350, %343
%358 = load i32, i32* %22
%359 = add nsw i32 %358, 1
%360 = srem i32 %359, 8
store i32 %360, i32* %22
%361 = load i32, i32* %22
%362 = icmp eq i32 %361, 0
br i1 %362, label %363, label %398
363: ; preds = %357
%364 = load i32, i32* %17
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [1024 x i8], [1024 x i8]* %10, i64 0, i64 %365
store i8 124, i8* %366
%367 = getelementptr inbounds [1024 x i8], [1024 x i8]* %11, i64 0, i64 0
%368 = load i32, i32* %17
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds i8, i8* %367, i64 %369
%371 = load i32, i32* %21
%372 = trunc i32 %371 to i8
%373 = call i32 @sprintf(i8* %370, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i8 zeroext %372)
store i32 %373, i32* %19
%374 = load i32, i32* %17
%375 = load i32, i32* %19
%376 = add nsw i32 %374, %375
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [1024 x i8], [1024 x i8]* %11, i64 0, i64 %377
store i8 32, i8* %378
%379 = load i32, i32* %21
%380 = icmp ne i32 %379, 0
br i1 %380, label %381, label %395
381: ; preds = %363
%382 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 0
%383 = load i32, i32* %17
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i8, i8* %382, i64 %384
%386 = getelementptr inbounds i8, i8* %385, i64 -8
%387 = load i8, i8* %13
%388 = call i32 @sprintf(i8* %386, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8 zeroext %387)
store i32 %388, i32* %19
%389 = load i32, i32* %17
%390 = load i32, i32* %19
%391 = add nsw i32 %389, %390
%392 = sub nsw i32 %391, 8
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 %393
store i8 32, i8* %394
br label %395
395: ; preds = %381, %363
store i8 0, i8* %13
%396 = load i32, i32* %21
%397 = add nsw i32 %396, 1
store i32 %397, i32* %21
br label %405
398: ; preds = %357
%399 = load i32, i32* %22
%400 = add nsw i32 48, %399
%401 = trunc i32 %400 to i8
%402 = load i32, i32* %17
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [1024 x i8], [1024 x i8]* %10, i64 0, i64 %403
store i8 %401, i8* %404
br label %405
405: ; preds = %398, %395
%406 = load i32, i32* %17
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds [1024 x i8], [1024 x i8]* %6, i64 0, i64 %407
%409 = load i8, i8* %408
%410 = sext i8 %409 to i32
%411 = icmp eq i32 %410, 49
br i1 %411, label %412, label %426
412: ; preds = %405
%413 = load i32, i32* %17
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds [1024 x i8], [1024 x i8]* %9, i64 0, i64 %414
%416 = load i8, i8* %415
%417 = sext i8 %416 to i32
%418 = icmp ne i32 %417, 42
br i1 %418, label %419, label %426
419: ; preds = %412
%420 = load i32, i32* %22
%421 = shl i32 1, %420
%422 = load i8, i8* %13
%423 = zext i8 %422 to i32
%424 = or i32 %423, %421
%425 = trunc i32 %424 to i8
store i8 %425, i8* %13
br label %426
426: ; preds = %419, %412, %405
br label %427
427: ; preds = %426, %350
br label %428
428: ; preds = %427, %342
br label %429
429: ; preds = %428
%430 = load i32, i32* %17
%431 = add nsw i32 %430, 1
store i32 %431, i32* %17
br label %288
432: ; preds = %288
store i32 0, i32* %17
br label %433
433: ; preds = %444, %432
%434 = load i32, i32* %17
%435 = load i32, i32* %15
%436 = icmp ne i32 %434, %435
br i1 %436, label %437, label %447
437: ; preds = %433
%438 = load i32, i32* %17
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds [1024 x i8], [1024 x i8]* %9, i64 0, i64 %439
%441 = load i8, i8* %440
%442 = sext i8 %441 to i32
%443 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %442)
br label %444
444: ; preds = %437
%445 = load i32, i32* %17
%446 = add nsw i32 %445, 1
store i32 %446, i32* %17
br label %433
447: ; preds = %433
%448 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %17
br label %449
449: ; preds = %460, %447
%450 = load i32, i32* %17
%451 = load i32, i32* %15
%452 = icmp ne i32 %450, %451
br i1 %452, label %453, label %463
453: ; preds = %449
%454 = load i32, i32* %17
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds [1024 x i8], [1024 x i8]* %10, i64 0, i64 %455
%457 = load i8, i8* %456
%458 = sext i8 %457 to i32
%459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %458)
br label %460
460: ; preds = %453
%461 = load i32, i32* %17
%462 = add nsw i32 %461, 1
store i32 %462, i32* %17
br label %449
463: ; preds = %449
%464 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %17
br label %465
465: ; preds = %476, %463
%466 = load i32, i32* %17
%467 = load i32, i32* %15
%468 = icmp ne i32 %466, %467
br i1 %468, label %469, label %479
469: ; preds = %465
%470 = load i32, i32* %17
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds [1024 x i8], [1024 x i8]* %11, i64 0, i64 %471
%473 = load i8, i8* %472
%474 = sext i8 %473 to i32
%475 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %474)
br label %476
476: ; preds = %469
%477 = load i32, i32* %17
%478 = add nsw i32 %477, 1
store i32 %478, i32* %17
br label %465
479: ; preds = %465
%480 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %17
br label %481
481: ; preds = %492, %479
%482 = load i32, i32* %17
%483 = load i32, i32* %15
%484 = icmp ne i32 %482, %483
br i1 %484, label %485, label %495
485: ; preds = %481
%486 = load i32, i32* %17
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds [1024 x i8], [1024 x i8]* %12, i64 0, i64 %487
%489 = load i8, i8* %488
%490 = sext i8 %489 to i32
%491 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0), i32 %490)
br label %492
492: ; preds = %485
%493 = load i32, i32* %17
%494 = add nsw i32 %493, 1
store i32 %494, i32* %17
br label %481
495: ; preds = %481
%496 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
store i32 0, i32* %3
br label %497
497: ; preds = %495, %185, %55
%498 = load i32, i32* %3
ret i32 %498
}

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