#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int atoi(char *);
int atol(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(int *);
int *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int strlen(char *);
int main(int argc, char *argv[]) {
  int *a, *b, c = 0, g, h, i = 0, j, l, m, y, len, opt;
  long f, k, n = 0, z, step = 0, maxstep;
  char *bm;
  if (argc < 2) {
    printf("Usage: %s ini [max] [opt] [step]\n", argv[0]);
    printf("See comment in the source: http://gyafun.jp/ln/basmat.cgi?ini=s\n");
    return 0;
  }
  bm = argv[1];
  z = (argc > 2) ? atol(argv[2]) : 20;
  if (z < 1)
    z = 1;
  opt = (argc > 3) ? atoi(argv[3]) : 1;
  maxstep = (argc > 4) ? atoi(argv[4]) : 0;
  if (maxstep < 0)
    maxstep = 0;
  len = strlen(bm);
  for (m = 0; m < len; m++) {
    if (bm[m] == ',')
      i++;
    if (bm[m] == ')') {
      if (c < i)
        c = i;
      i = 0;
    }
    if (bm[m] == '[')
      m = len;
  }
  y = c + 1;
  a = malloc(sizeof(int) * y * z);
  b = malloc(sizeof(int) * y);
  if (a == NULL || b == NULL) {
    printf("Allocation failed.\n");
    exit(-1);
  }
  i = j = a[0] = 0;
  for (m = 0; m < len; m++) {
    if (bm[m] == ',')
      i++, a[i + j * y] = 0;
    if (bm[m] == ')')
      j++, i = 0, a[i + j * y] = 0;
    if (bm[m] == '[') {
      for (; m < len; m++) {
        k = bm[m] - '0';
        if (k >= 0 && k <= 9)
          n = n * 10 + k;
      }
    }
    k = bm[m] - '0';
    if (k >= 0 && k <= 9)
      a[i + j * y] = a[i + j * y] * 10 + k;
  }
  if (n < 1)
    n = 2;
  if (j == 0) {
    printf("Invalid initial parameter.\n");
    return 0;
  }
  for (f = j - 1; f >= 0; f--) {
    for (i = 0; i <= f; i++) {
      printf("(");
      for (j = 0; j < c; j++)
        printf("%d,", a[j + i * y]);
      printf("%d)", a[c + i * y]);
    }
    printf("[%ld]\n", n);
    if (opt == 2)
      n++;
    if (opt == 3)
      n *= n;
    if (a[f * y] == 0) {
      g = 0;
      if (opt == 4)
        n++;
    } else {
      m = c + 1;
      g = 0;
      for (j = 0; j <= c; j++) {
        if (a[j + f * y] == 0)
          m = j, j = c + 1;
      }
      for (k = 0; k <= f; k++) {
        h = 1;
        for (l = 0; l < m; l++)
          if (a[l + (f - k) * y] >= a[l + f * y])
            h = 0;
        if (h) {
          for (l = 0; l <= c; l++)
            b[l] = (l < m - 1) ? a[l + f * y] - a[l + (f - k) * y] : 0;
          g = k;
          k = f + 1;
        }
      }
    }
    k = (opt == 4) ? f + g * (n - 1) : f + g * n;
    if (k > z) {
      printf("Length of sequence exceeds %ld at next step.\n", z);
      free(a);
      free(b);
      return 0;
    }
    if (maxstep && step++ >= maxstep) {
      printf("Maximum step of calculation %ld has reached.\n", maxstep);
      free(a);
      free(b);
      return 0;
    }
    while (f < k) {
      for (l = 0; l <= c; l++)
        a[l + f * y] = a[l + (f - g) * y] + b[l];
      f++;
    }
  }
  printf("Finished. n = %ld\n", n);
  free(a);
  free(b);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x30(%rbp)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x70(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11e0 <main+0x70>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xe55(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a15 <main+0x8a5>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x2,-0x8(%rbp)
jle    120e <main+0x9e>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1070 <atol@plt>
mov    %eax,-0x84(%rbp)
jmp    121e <main+0xae>
mov    $0x14,%eax
mov    %eax,-0x84(%rbp)
jmp    121e <main+0xae>
mov    -0x84(%rbp),%eax
cltq
mov    %rax,-0x68(%rbp)
cmpq   $0x1,-0x68(%rbp)
jge    123d <main+0xcd>
movq   $0x1,-0x68(%rbp)
cmpl   $0x3,-0x8(%rbp)
jle    125f <main+0xef>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x88(%rbp)
jmp    126f <main+0xff>
mov    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    126f <main+0xff>
mov    -0x88(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x4,-0x8(%rbp)
jle    129a <main+0x12a>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rdi
call   1080 <atoi@plt>
mov    %eax,-0x8c(%rbp)
jmp    12a7 <main+0x137>
xor    %eax,%eax
mov    %eax,-0x8c(%rbp)
jmp    12a7 <main+0x137>
mov    -0x8c(%rbp),%eax
cltq
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
jge    12c6 <main+0x156>
movq   $0x0,-0x78(%rbp)
mov    -0x80(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    135f <main+0x1ef>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    1303 <main+0x193>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    1331 <main+0x1c1>
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    132a <main+0x1ba>
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5b,%eax
jne    134c <main+0x1dc>
mov    -0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1351 <main+0x1e1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12d9 <main+0x169>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
imul   -0x68(%rbp),%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     13a9 <main+0x239>
cmpq   $0x0,-0x20(%rbp)
jne    13c1 <main+0x251>
lea    0xcb3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   1090 <exit@plt>
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    154c <main+0x3dc>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    1424 <main+0x2b4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    1463 <main+0x2f3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5b,%eax
jne    14d9 <main+0x369>
jmp    147d <main+0x30d>
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14d4 <main+0x364>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
cltq
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jl     14c1 <main+0x351>
cmpq   $0x9,-0x58(%rbp)
jg     14c1 <main+0x351>
imul   $0xa,-0x60(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    14c6 <main+0x356>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    147d <main+0x30d>
jmp    14d9 <main+0x369>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
cltq
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jl     1539 <main+0x3c9>
cmpq   $0x9,-0x58(%rbp)
jg     1539 <main+0x3c9>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
imul   $0xa,(%rax,%rcx,4),%eax
cltq
add    -0x58(%rbp),%rax
mov    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%esi
imul   -0x40(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    153e <main+0x3ce>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13e0 <main+0x270>
cmpq   $0x1,-0x60(%rbp)
jge    155f <main+0x3ef>
movq   $0x2,-0x60(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    1583 <main+0x413>
lea    0xb07(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a15 <main+0x8a5>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jl     19ea <main+0x87a>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x50(%rbp),%rax
jg     1634 <main+0x4c4>
lea    0xadd(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1602 <main+0x492>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
lea    0xaa8(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15c4 <main+0x454>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
lea    0xa7a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15a1 <main+0x431>
mov    -0x60(%rbp),%rsi
lea    0xa5e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x2,-0x48(%rbp)
jne    165c <main+0x4ec>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
cmpl   $0x3,-0x48(%rbp)
jne    1673 <main+0x503>
mov    -0x60(%rbp),%rax
imul   -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x40(%rbp),%rdx
imul   %rdx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    16af <main+0x53f>
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x48(%rbp)
jne    16aa <main+0x53a>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1868 <main+0x6f8>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1715 <main+0x5a5>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x40(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1702 <main+0x592>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1707 <main+0x597>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16c6 <main+0x556>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x50(%rbp),%rax
jg     1863 <main+0x6f3>
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    179d <main+0x62d>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rdx
sub    -0x58(%rbp),%rdx
movslq -0x40(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    -0x50(%rbp),%rsi
movslq -0x40(%rbp),%rdi
imul   %rdi,%rsi
add    %rsi,%rdx
cmp    (%rcx,%rdx,4),%eax
jl     178a <main+0x61a>
movl   $0x0,-0x2c(%rbp)
jmp    178f <main+0x61f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1739 <main+0x5c9>
cmpl   $0x0,-0x2c(%rbp)
je     184d <main+0x6dd>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     183a <main+0x6ca>
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    180e <main+0x69e>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x40(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    -0x50(%rbp),%rsi
sub    -0x58(%rbp),%rsi
movslq -0x40(%rbp),%rdi
imul   %rdi,%rsi
add    %rsi,%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x90(%rbp)
jmp    181b <main+0x6ab>
xor    %eax,%eax
mov    %eax,-0x90(%rbp)
jmp    181b <main+0x6ab>
mov    -0x90(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17ae <main+0x63e>
mov    -0x58(%rbp),%rax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1852 <main+0x6e2>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    171d <main+0x5ad>
jmp    1868 <main+0x6f8>
cmpl   $0x4,-0x48(%rbp)
jne    1895 <main+0x725>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    -0x60(%rbp),%rdx
sub    $0x1,%rdx
imul   %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
jmp    18ac <main+0x73c>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   -0x60(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x68(%rbp),%rax
jle    18f5 <main+0x785>
mov    -0x68(%rbp),%rsi
lea    0x7d4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a15 <main+0x8a5>
cmpq   $0x0,-0x78(%rbp)
je     1949 <main+0x7d9>
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x70(%rbp)
cmp    -0x78(%rbp),%rax
jl     1949 <main+0x7d9>
mov    -0x78(%rbp),%rsi
lea    0x7ae(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a15 <main+0x8a5>
jmp    194e <main+0x7de>
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    19d4 <main+0x864>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     19c3 <main+0x853>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x28(%rbp),%rsi
sub    %rsi,%rdx
movslq -0x40(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    -0x50(%rbp),%rsi
movslq -0x40(%rbp),%rdi
imul   %rdi,%rsi
add    %rsi,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1963 <main+0x7f3>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    194e <main+0x7de>
jmp    19d9 <main+0x869>
mov    -0x50(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
jmp    158f <main+0x41f>
mov    -0x60(%rbp),%rsi
lea    0x70b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %rsi,%rbx
cmp    $0x1,%edi
jg     11cb <main+0x3b>
mov    (%rbx),%rsi
lea    0xe5d(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xf1d(%rip),%rdi
call   1050 <puts@plt>
jmp    1cc1 <main+0xb31>
mov    %edi,%ebp
mov    0x8(%rbx),%r12
mov    $0x14,%eax
mov    %rax,0x30(%rsp)
movl   $0x1,0x24(%rsp)
cmp    $0x2,%edi
je     121f <main+0x8f>
mov    0x10(%rbx),%rdi
call   1090 <atol@plt>
cltq
test   %rax,%rax
mov    $0x1,%ecx
cmovg  %rax,%rcx
mov    %rcx,0x30(%rsp)
cmp    $0x4,%ebp
jb     121f <main+0x8f>
mov    0x18(%rbx),%rdi
call   10a0 <atoi@plt>
mov    %eax,0x24(%rsp)
cmp    $0x4,%ebp
jne    1c77 <main+0xae7>
xor    %eax,%eax
mov    %rax,0x10(%rsp)
xor    %r14d,%r14d
test   %r14d,%r14d
mov    $0x0,%eax
cmovns %r14d,%eax
mov    %rax,0x68(%rsp)
mov    %r12,%rdi
call   1060 <strlen@plt>
mov    %eax,%r15d
test   %eax,%eax
jle    12a3 <main+0x113>
xor    %eax,%eax
xor    %ecx,%ecx
mov    %rcx,0x10(%rsp)
xor    %edx,%edx
xor    %ecx,%ecx
jmp    126a <main+0xda>
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
mov    %esi,%edx
cmp    %r15d,%esi
jge    12a3 <main+0x113>
mov    0x10(%rsp),%rsi
movslq %edx,%rdi
movzbl (%r12,%rdi,1),%ebx
xor    %edi,%edi
cmp    $0x2c,%bl
sete   %dil
add    %edi,%ecx
cmp    %ecx,%esi
mov    %esi,%edi
cmovl  %ecx,%edi
cmp    $0x29,%bl
cmove  %eax,%ecx
cmovne %esi,%edi
mov    %rdi,0x10(%rsp)
mov    %r15d,%esi
cmp    $0x5b,%bl
je     1260 <main+0xd0>
mov    %edx,%esi
jmp    1260 <main+0xd0>
movslq 0x10(%rsp),%rax
mov    %rax,0xf8(%rsp)
add    $0x1,%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,4),%ebp
mov    %ebp,%edi
imul   0x30(%rsp),%edi
call   1080 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rbx,(%rsp)
test   %rbx,%rbx
je     1cd5 <main+0xb45>
mov    %rax,%r13
test   %rax,%rax
je     1cd5 <main+0xb45>
mov    (%rsp),%rax
movl   $0x0,(%rax)
test   %r15d,%r15d
jle    1c5b <main+0xacb>
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
movslq %r15d,%r9
lea    -0x2(%r9),%r8
xor    %edx,%edx
xor    %edi,%edi
xor    %r10d,%r10d
xor    %esi,%esi
jmp    134a <main+0x1ba>
mov    %r10d,%ebp
imul   0xc(%rsp),%ebp
add    %esi,%ebp
add    $0x1,%ebp
add    $0x1,%esi
movslq %ebp,%rbp
mov    (%rsp),%rcx
movl   $0x0,(%rcx,%rbp,4)
add    $0x1,%edi
cmp    %r15d,%edi
jge    1455 <main+0x2c5>
movslq %edi,%rbp
mov    (%r12,%rbp,1),%bl
cmp    $0x29,%bl
je     1430 <main+0x2a0>
cmp    $0x2c,%bl
je     1320 <main+0x190>
cmp    $0x5b,%bl
jne    13f3 <main+0x263>
cmp    %r15d,%edi
jge    133e <main+0x1ae>
lea    0x1(%rbp),%rbx
cmp    %r9,%rbx
je     13ec <main+0x25c>
not    %edi
add    %r15d,%edi
test   $0x1,%dil
je     139e <main+0x20e>
movsbq 0x1(%r12,%rbp,1),%rdi
lea    -0x30(%rdi),%ebx
cmp    $0xa,%bl
lea    (%rdx,%rdx,4),%rbx
lea    -0x30(%rdi,%rbx,2),%rdi
cmovb  %rdi,%rdx
lea    0x2(%rbp),%rbx
cmp    %rbp,%r8
je     13ec <main+0x25c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbq (%r12,%rbx,1),%rdi
lea    -0x30(%rdi),%ebp
cmp    $0xa,%bpl
lea    (%rdx,%rdx,4),%rbp
lea    -0x30(%rdi,%rbp,2),%rdi
cmovae %rdx,%rdi
movsbq 0x1(%r12,%rbx,1),%rdx
lea    -0x30(%rdx),%ebp
cmp    $0xa,%bpl
lea    (%rdi,%rdi,4),%rbp
lea    -0x30(%rdx,%rbp,2),%rdx
cmovae %rdi,%rdx
add    $0x2,%rbx
cmp    %rbx,%r9
jne    13b0 <main+0x220>
mov    (%r12,%r9,1),%bl
mov    %r15d,%edi
lea    -0x30(%rbx),%ebp
cmp    $0x9,%bpl
ja     133e <main+0x1ae>
movzbl %bl,%ebp
mov    %r10d,%ebx
imul   0xc(%rsp),%ebx
add    %esi,%ebx
movslq %ebx,%rbx
mov    (%rsp),%rax
mov    (%rax,%rbx,4),%ecx
lea    (%rcx,%rcx,4),%ecx
lea    -0x30(%rbp,%rcx,2),%ecx
mov    %ecx,(%rax,%rbx,4)
jmp    133e <main+0x1ae>
cs nopw 0x0(%rax,%rax,1)
mov    %r10,%rax
add    $0x1,%eax
mov    %rax,%r10
mov    %eax,%esi
imul   0xc(%rsp),%esi
movslq %esi,%rsi
mov    (%rsp),%rcx
movl   $0x0,(%rcx,%rsi,4)
xor    %esi,%esi
jmp    133e <main+0x1ae>
test   %r10d,%r10d
je     1c5b <main+0xacb>
test   %rdx,%rdx
mov    $0x2,%eax
cmovg  %rdx,%rax
mov    %rax,0x28(%rsp)
test   %r10d,%r10d
jle    1c69 <main+0xad9>
mov    %r14d,0x64(%rsp)
add    $0xffffffff,%r10d
xor    %ecx,%ecx
mov    0x24(%rsp),%eax
cmp    $0x2,%eax
sete   %cl
mov    %rcx,0x98(%rsp)
xor    %ecx,%ecx
cmp    $0x4,%eax
sete   %cl
mov    %rcx,0x88(%rsp)
neg    %rcx
mov    %rcx,0x90(%rsp)
mov    0x10(%rsp),%r15
mov    %r15d,%edx
mov    0xc(%rsp),%r8d
mov    %r8d,%eax
and    $0xfffffff8,%eax
mov    %rax,0xc0(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xb8(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r8d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x100(%rsp)
mov    %rcx,%rax
mov    %rcx,0xb0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xa0(%rsp)
mov    %r8,%rax
neg    %rax
mov    %rax,0xe0(%rsp)
mov    0x18(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x80(%rsp)
mov    (%rsp),%rax
lea    0x30(%rax),%rcx
mov    %rcx,0x40(%rsp)
add    $0x4,%rax
mov    %rax,0x50(%rsp)
xor    %eax,%eax
mov    %rax,0x78(%rsp)
mov    %r10,%rax
mov    %r8,0x38(%rsp)
mov    %rdx,0xf0(%rsp)
mov    %r13,0x70(%rsp)
jmp    156d <main+0x3dd>
xchg   %ax,%ax
lea    -0x1(%r14),%rax
test   %r14,%r14
jle    1c69 <main+0xad9>
mov    %rax,0x58(%rsp)
mov    (%rsp),%rbx
xor    %r14d,%r14d
jmp    15b8 <main+0x428>
nopl   0x0(%rax,%rax,1)
add    0xf8(%rsp),%rbp
mov    (%rsp),%rax
mov    (%rax,%rbp,4),%esi
lea    0xaa0(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x1,%r14
mov    %r14d,%eax
add    0x80(%rsp),%rbx
cmp    %rax,0x58(%rsp)
mov    0x10(%rsp),%r15
jl     1610 <main+0x480>
mov    $0x28,%edi
call   1040 <putchar@plt>
mov    %r14,%rbp
imul   0x18(%rsp),%rbp
test   %r15d,%r15d
lea    0xa5d(%rip),%r12
mov    0xf0(%rsp),%r13
jle    1580 <main+0x3f0>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%r15,4),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
add    $0x1,%r15
cmp    %r15,%r13
jne    15f0 <main+0x460>
jmp    1580 <main+0x3f0>
nopl   0x0(%rax)
lea    0xa23(%rip),%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
add    0x98(%rsp),%rbx
cmpl   $0x3,0x24(%rsp)
mov    $0x1,%edi
cmove  %rbx,%rdi
imul   %rbx,%rdi
mov    0x58(%rsp),%r14
mov    %r14,%rbp
imul   0x18(%rsp),%rbp
mov    (%rsp),%rax
cmpl   $0x0,(%rax,%rbp,4)
je     19c0 <main+0x830>
mov    0xc(%rsp),%eax
test   %r15d,%r15d
movdqa 0x995(%rip),%xmm7
mov    0x70(%rsp),%r13
js     16b0 <main+0x520>
xor    %ecx,%ecx
mov    0xc(%rsp),%eax
jmp    168a <main+0x4fa>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%edx
lea    0x1(%rdx),%ecx
cmp    %r15d,%edx
jge    16b0 <main+0x520>
movslq %ecx,%rdx
add    %rbp,%rdx
mov    (%rsp),%rsi
cmpl   $0x0,(%rsi,%rdx,4)
jne    1680 <main+0x4f0>
mov    0xc(%rsp),%eax
mov    %eax,%edx
mov    %ecx,%eax
jmp    1682 <main+0x4f2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdi,0x28(%rsp)
lea    -0x1(%rax),%ecx
lea    0x1(%r14),%rdx
mov    %rdx,0xe8(%rsp)
movslq %ecx,%rdx
mov    %eax,%esi
mov    %esi,%eax
and    $0xfffffff8,%eax
mov    %rax,0xd8(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xd0(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0xc8(%rsp)
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%rbp,4),%rdi
mov    (%rsp),%rax
lea    (%rax,%rbp,4),%r10
mov    0x50(%rsp),%rax
mov    %rbp,0x48(%rsp)
lea    (%rax,%rbp,4),%r8
xor    %r9d,%r9d
xor    %r12d,%r12d
jmp    1760 <main+0x5d0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,0x0(%r13,%rbx,4)
mov    %r9d,%r12d
mov    0xe8(%rsp),%r9
lea    0x1(%r9),%rax
cmp    %r9,%r14
mov    %rax,%r9
jle    19b0 <main+0x820>
test   %esi,%esi
jle    18c1 <main+0x731>
sub    %r9,%r14
imul   0x18(%rsp),%r14
cmp    $0x8,%esi
jae    1790 <main+0x600>
mov    $0x1,%eax
xor    %ebx,%ebx
xor    %r11d,%r11d
jmp    188e <main+0x6fe>
cs nopw 0x0(%rax,%rax,1)
nop
cmpq   $0x0,0xd0(%rsp)
je     1984 <main+0x7f4>
mov    0x40(%rsp),%rax
lea    (%rax,%r14,4),%rax
mov    0xa8(%rsp),%rbp
xor    %ebx,%ebx
movdqa %xmm7,%xmm0
movdqa %xmm7,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rax,%rbx,4),%xmm2
movdqu -0x20(%rax,%rbx,4),%xmm3
movdqu -0x10(%rax,%rbx,4),%xmm4
movdqu (%rax,%rbx,4),%xmm5
movdqu -0x30(%rdi,%rbx,4),%xmm6
pcmpgtd %xmm2,%xmm6
movdqu -0x20(%rdi,%rbx,4),%xmm2
pcmpgtd %xmm3,%xmm2
movdqu -0x10(%rdi,%rbx,4),%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm6,%xmm3
pand   %xmm3,%xmm0
movdqu (%rdi,%rbx,4),%xmm3
pcmpgtd %xmm5,%xmm3
pand   %xmm2,%xmm3
pand   %xmm3,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    17c0 <main+0x630>
testb  $0x1,0xc8(%rsp)
01
je     1855 <main+0x6c5>
lea    (%r14,%rbx,1),%rax
mov    (%rsp),%rcx
movdqu (%rcx,%rax,4),%xmm2
movdqu 0x10(%rcx,%rax,4),%xmm3
add    0x48(%rsp),%rbx
movdqu (%rcx,%rbx,4),%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
movdqu 0x10(%rcx,%rbx,4),%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpeqd %xmm7,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pcmpeqd %xmm7,%xmm2
movmskps %xmm2,%ecx
xor    %eax,%eax
cmp    $0xf,%ecx
sete   %al
mov    0xd8(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rsi,%rcx
mov    $0x0,%r11d
je     18b4 <main+0x724>
mov    (%rsp),%rcx
lea    (%rcx,%r14,4),%rcx
cs nopw 0x0(%rax,%rax,1)
mov    (%rcx,%rbx,4),%ebp
cmp    (%r10,%rbx,4),%ebp
cmovge %r11d,%eax
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    18a0 <main+0x710>
test   %eax,%eax
mov    0x58(%rsp),%r14
je     1750 <main+0x5c0>
test   %r15d,%r15d
js     1745 <main+0x5b5>
mov    %r14,%r11
sub    %r9,%r11
imul   0x18(%rsp),%r11
test   %r15d,%r15d
je     1951 <main+0x7c1>
mov    0x50(%rsp),%rax
lea    (%rax,%r11,4),%rbp
xor    %eax,%eax
jmp    1903 <main+0x773>
nopl   0x0(%rax,%rax,1)
mov    %ecx,0x4(%r13,%rbx,4)
add    $0x1,%rax
cmp    0x100(%rsp),%rax
je     1940 <main+0x7b0>
mov    %rax,%rbx
xor    %ecx,%ecx
mov    $0x0,%eax
cmp    %rdx,%rbx
jge    191b <main+0x78b>
mov    -0x4(%r8,%rbx,4),%eax
sub    -0x4(%rbp,%rbx,4),%eax
mov    %eax,0x0(%r13,%rbx,4)
lea    0x1(%rbx),%rax
cmp    %rdx,%rax
jge    18f0 <main+0x760>
mov    (%r8,%rbx,4),%ecx
sub    0x0(%rbp,%rbx,4),%ecx
jmp    18f0 <main+0x760>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rbx
testb  $0x1,0x38(%rsp)
je     1745 <main+0x5b5>
jmp    195e <main+0x7ce>
xor    %ebx,%ebx
testb  $0x1,0x38(%rsp)
je     1745 <main+0x5b5>
xor    %eax,%eax
cmp    %rdx,%rbx
jge    1740 <main+0x5b0>
mov    0x48(%rsp),%rax
add    %rbx,%rax
mov    (%rsp),%rcx
mov    (%rcx,%rax,4),%eax
add    %rbx,%r11
sub    (%rcx,%r11,4),%eax
jmp    1740 <main+0x5b0>
xor    %ebx,%ebx
movdqa %xmm7,%xmm0
movdqa %xmm7,%xmm1
testb  $0x1,0xc8(%rsp)
01
jne    1822 <main+0x692>
jmp    1855 <main+0x6c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rdx
mov    0x28(%rsp),%rdi
jmp    19d3 <main+0x843>
nopl   0x0(%rax)
mov    %rbp,%rdx
add    0x88(%rsp),%rdi
xor    %r12d,%r12d
mov    0x70(%rsp),%r13
mov    %r12d,%ecx
mov    0x90(%rsp),%rax
add    %rdi,%rax
mov    %rcx,%r12
imul   %rcx,%rax
lea    (%rax,%r14,1),%r11
cmp    0x30(%rsp),%r11
mov    0x38(%rsp),%r8
mov    0x78(%rsp),%rcx
jg     1c8f <main+0xaff>
cmpl   $0x0,0x64(%rsp)
jle    1a17 <main+0x887>
cmp    0x68(%rsp),%rcx
jge    1c9d <main+0xb0d>
add    $0x1,%rcx
mov    %rcx,0x78(%rsp)
mov    %rdi,0x28(%rsp)
test   %rax,%rax
jle    1560 <main+0x3d0>
mov    (%rsp),%rbp
mov    %rdx,%rbx
lea    0x0(,%rdx,4),%rax
add    %rbp,%rax
lea    (%rdx,%r8,1),%rcx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
mov    %r14,%rdx
sub    %r12,%rdx
imul   0x18(%rsp),%rdx
lea    0x0(,%rdx,4),%rsi
add    %rbp,%rsi
lea    (%rdx,%r8,1),%rdi
lea    0x0(,%rdi,4),%rdi
add    %rbp,%rdi
cmp    %rdi,%rax
setb   %al
cmp    %rcx,%rsi
setb   %r10b
and    %al,%r10b
mov    0x40(%rsp),%rax
lea    (%rax,%rdx,4),%rdi
lea    (%rax,%rbx,4),%rcx
mov    0x50(%rsp),%rax
lea    (%rax,%rbx,4),%rax
jmp    1ac1 <main+0x931>
nopl   0x0(%rax)
add    $0x1,%r14
mov    0x80(%rsp),%rdx
add    %rdx,%rdi
add    %rdx,%rcx
add    %rdx,%rax
add    %rdx,%rsi
cmp    %r11,%r14
jge    1560 <main+0x3d0>
test   %r15d,%r15d
js     1aa0 <main+0x910>
cmpl   $0x8,0xc(%rsp)
setb   %bl
mov    %r14,%rdx
sub    %r12,%rdx
mov    0x18(%rsp),%rbp
imul   %rbp,%rdx
mov    %r14,%r9
imul   %rbp,%r9
or     %r10b,%bl
je     1af0 <main+0x960>
xor    %ebp,%ebp
jmp    1bd6 <main+0xa46>
cmpq   $0x0,0xb8(%rsp)
je     1c46 <main+0xab6>
mov    0xa0(%rsp),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movdqu -0x30(%rdi,%rbp,4),%xmm0
movdqu -0x20(%rdi,%rbp,4),%xmm1
movdqu 0x0(%r13,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r13,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rcx,%rbp,4)
movdqu %xmm0,-0x20(%rcx,%rbp,4)
movdqu -0x10(%rdi,%rbp,4),%xmm0
movdqu (%rdi,%rbp,4),%xmm1
movdqu 0x20(%r13,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x30(%r13,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rcx,%rbp,4)
movdqu %xmm0,(%rcx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1b10 <main+0x980>
testb  $0x1,0xb0(%rsp)
01
je     1bc2 <main+0xa32>
mov    %r14,%r8
lea    (%rdx,%rbp,1),%r14
mov    (%rsp),%rbx
movdqu (%rbx,%r14,4),%xmm0
movdqu 0x10(%rbx,%r14,4),%xmm1
mov    %r8,%r14
mov    0x38(%rsp),%r8
movdqu 0x0(%r13,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r13,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
add    %r9,%rbp
movdqu %xmm2,(%rbx,%rbp,4)
movdqu %xmm0,0x10(%rbx,%rbp,4)
mov    0xc0(%rsp),%rbx
mov    %rbx,%rbp
cmp    %r8,%rbx
je     1aa0 <main+0x910>
mov    %rbp,%rbx
test   $0x1,%r8b
je     1c08 <main+0xa78>
add    %rbp,%rdx
mov    0x0(%r13,%rbp,4),%ebx
mov    %r14,%r8
mov    (%rsp),%r14
add    (%r14,%rdx,4),%ebx
add    %rbp,%r9
mov    %ebx,(%r14,%r9,4)
mov    %r8,%r14
mov    0x38(%rsp),%r8
mov    %rbp,%rbx
or     $0x1,%rbx
not    %rbp
cmp    0xe0(%rsp),%rbp
je     1aa0 <main+0x910>
nopl   0x0(%rax)
mov    0x0(%r13,%rbx,4),%edx
add    (%rsi,%rbx,4),%edx
mov    %edx,-0x4(%rax,%rbx,4)
mov    0x4(%r13,%rbx,4),%edx
add    0x4(%rsi,%rbx,4),%edx
mov    %edx,(%rax,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r8
jne    1c20 <main+0xa90>
jmp    1aa0 <main+0x910>
xor    %ebp,%ebp
testb  $0x1,0xb0(%rsp)
01
jne    1b7e <main+0x9ee>
jmp    1bc2 <main+0xa32>
lea    0x44e(%rip),%rdi
call   1050 <puts@plt>
jmp    1cc1 <main+0xb31>
lea    0x42d(%rip),%rdi
mov    0x28(%rsp),%rsi
jmp    1ca9 <main+0xb19>
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0x20(%rbx),%rdi
call   10a0 <atoi@plt>
mov    %eax,%r14d
jmp    1229 <main+0x99>
lea    0x3ab(%rip),%rdi
mov    0x30(%rsp),%rsi
jmp    1ca9 <main+0xb19>
lea    0x3cb(%rip),%rdi
mov    0x68(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x3ef(%rip),%rdi
call   1050 <puts@plt>
mov    $0xffffffff,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@.str = [34 x i8] c"Usage: %s ini [max] [opt] [step]\0A\00"
@.str.1 = [65 x i8] c"See comment in the source: http://gyafun.jp/ln/basmat.cgi?ini=s\0A\00"
@.str.2 = [20 x i8] c"Allocation failed.\0A\00"
@.str.3 = [28 x i8] c"Invalid initial parameter.\0A\00"
@.str.4 = [2 x i8] c"(\00"
@.str.5 = [4 x i8] c"%d,\00"
@.str.6 = [4 x i8] c"%d)\00"
@.str.7 = [7 x i8] c"[%ld]\0A\00"
@.str.8 = [46 x i8] c"Length of sequence exceeds %ld at next step.\0A\00"
@.str.9 = [46 x i8] c"Maximum step of calculation %ld has reached.\0A\00"
@.str.10 = [19 x i8] c"Finished. n = %ld\0A\00"
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 i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %8
store i32 0, i32* %11
store i64 0, i64* %20
store i64 0, i64* %22
%25 = load i32, i32* %4
%26 = icmp slt i32 %25, 2
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 ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i8* %30)
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %3
br label %580
33: ; preds = %2
%34 = load i8**, i8*** %5
%35 = getelementptr inbounds i8*, i8** %34, i64 1
%36 = load i8*, i8** %35
store i8* %36, i8** %24
%37 = load i32, i32* %4
%38 = icmp sgt i32 %37, 2
br i1 %38, label %39, label %44
39: ; preds = %33
%40 = load i8**, i8*** %5
%41 = getelementptr inbounds i8*, i8** %40, i64 2
%42 = load i8*, i8** %41
%43 = call i32 @atol(i8* %42)
br label %45
44: ; preds = %33
br label %45
45: ; preds = %44, %39
%46 = phi i32 [ %43, %39 ], [ 20, %44 ]
%47 = sext i32 %46 to i64
store i64 %47, i64* %21
%48 = load i64, i64* %21
%49 = icmp slt i64 %48, 1
br i1 %49, label %50, label %51
50: ; preds = %45
store i64 1, i64* %21
br label %51
51: ; preds = %50, %45
%52 = load i32, i32* %4
%53 = icmp sgt i32 %52, 3
br i1 %53, label %54, label %59
54: ; preds = %51
%55 = load i8**, i8*** %5
%56 = getelementptr inbounds i8*, i8** %55, i64 3
%57 = load i8*, i8** %56
%58 = call i32 @atoi(i8* %57)
br label %60
59: ; preds = %51
br label %60
60: ; preds = %59, %54
%61 = phi i32 [ %58, %54 ], [ 1, %59 ]
store i32 %61, i32* %17
%62 = load i32, i32* %4
%63 = icmp sgt i32 %62, 4
br i1 %63, label %64, label %69
64: ; preds = %60
%65 = load i8**, i8*** %5
%66 = getelementptr inbounds i8*, i8** %65, i64 4
%67 = load i8*, i8** %66
%68 = call i32 @atoi(i8* %67)
br label %70
69: ; preds = %60
br label %70
70: ; preds = %69, %64
%71 = phi i32 [ %68, %64 ], [ 0, %69 ]
%72 = sext i32 %71 to i64
store i64 %72, i64* %23
%73 = load i64, i64* %23
%74 = icmp slt i64 %73, 0
br i1 %74, label %75, label %76
75: ; preds = %70
store i64 0, i64* %23
br label %76
76: ; preds = %75, %70
%77 = load i8*, i8** %24
%78 = call i32 @strlen(i8* %77)
store i32 %78, i32* %16
store i32 0, i32* %14
br label %79
79: ; preds = %120, %76
%80 = load i32, i32* %14
%81 = load i32, i32* %16
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %123
83: ; preds = %79
%84 = load i8*, i8** %24
%85 = load i32, i32* %14
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = icmp eq i32 %89, 44
br i1 %90, label %91, label %94
91: ; preds = %83
%92 = load i32, i32* %11
%93 = add nsw i32 %92, 1
store i32 %93, i32* %11
br label %94
94: ; preds = %91, %83
%95 = load i8*, i8** %24
%96 = load i32, i32* %14
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %95, i64 %97
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = icmp eq i32 %100, 41
br i1 %101, label %102, label %109
102: ; preds = %94
%103 = load i32, i32* %8
%104 = load i32, i32* %11
%105 = icmp slt i32 %103, %104
br i1 %105, label %106, label %108
106: ; preds = %102
%107 = load i32, i32* %11
store i32 %107, i32* %8
br label %108
108: ; preds = %106, %102
store i32 0, i32* %11
br label %109
109: ; preds = %108, %94
%110 = load i8*, i8** %24
%111 = load i32, i32* %14
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, 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 %119
117: ; preds = %109
%118 = load i32, i32* %16
store i32 %118, i32* %14
br label %119
119: ; preds = %117, %109
br label %120
120: ; preds = %119
%121 = load i32, i32* %14
%122 = add nsw i32 %121, 1
store i32 %122, i32* %14
br label %79
123: ; preds = %79
%124 = load i32, i32* %8
%125 = add nsw i32 %124, 1
store i32 %125, i32* %15
%126 = load i32, i32* %15
%127 = sext i32 %126 to i64
%128 = mul i64 4, %127
%129 = load i64, i64* %21
%130 = mul i64 %128, %129
%131 = trunc i64 %130 to i32
%132 = call i32* @malloc(i32 %131)
store i32* %132, i32** %6
%133 = load i32, i32* %15
%134 = sext i32 %133 to i64
%135 = mul i64 4, %134
%136 = trunc i64 %135 to i32
%137 = call i32* @malloc(i32 %136)
store i32* %137, i32** %7
%138 = load i32*, i32** %6
%139 = icmp eq i32* %138, null
br i1 %139, label %143, label %140
140: ; preds = %123
%141 = load i32*, i32** %7
%142 = icmp eq i32* %141, null
br i1 %142, label %143, label %146
143: ; preds = %140, %123
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0))
%145 = call i32 @exit(i32 -1)
unreachable
146: ; preds = %140
%147 = load i32*, i32** %6
%148 = getelementptr inbounds i32, i32* %147, i64 0
store i32 0, i32* %148
store i32 0, i32* %12
store i32 0, i32* %11
store i32 0, i32* %14
br label %149
149: ; preds = %266, %146
%150 = load i32, i32* %14
%151 = load i32, i32* %16
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %269
153: ; preds = %149
%154 = load i8*, i8** %24
%155 = load i32, i32* %14
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %154, i64 %156
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp eq i32 %159, 44
br i1 %160, label %161, label %172
161: ; preds = %153
%162 = load i32, i32* %11
%163 = add nsw i32 %162, 1
store i32 %163, i32* %11
%164 = load i32*, i32** %6
%165 = load i32, i32* %11
%166 = load i32, i32* %12
%167 = load i32, i32* %15
%168 = mul nsw i32 %166, %167
%169 = add nsw i32 %165, %168
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %164, i64 %170
store i32 0, i32* %171
br label %172
172: ; preds = %161, %153
%173 = load i8*, i8** %24
%174 = load i32, i32* %14
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8, i8* %173, i64 %175
%177 = load i8, i8* %176
%178 = sext i8 %177 to i32
%179 = icmp eq i32 %178, 41
br i1 %179, label %180, label %191
180: ; preds = %172
%181 = load i32, i32* %12
%182 = add nsw i32 %181, 1
store i32 %182, i32* %12
store i32 0, i32* %11
%183 = load i32*, i32** %6
%184 = load i32, i32* %11
%185 = load i32, i32* %12
%186 = load i32, i32* %15
%187 = mul nsw i32 %185, %186
%188 = add nsw i32 %184, %187
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %183, i64 %189
store i32 0, i32* %190
br label %191
191: ; preds = %180, %172
%192 = load i8*, i8** %24
%193 = load i32, i32* %14
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8, i8* %192, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = icmp eq i32 %197, 91
br i1 %198, label %199, label %228
199: ; preds = %191
br label %200
200: ; preds = %224, %199
%201 = load i32, i32* %14
%202 = load i32, i32* %16
%203 = icmp slt i32 %201, %202
br i1 %203, label %204, label %227
204: ; preds = %200
%205 = load i8*, i8** %24
%206 = load i32, i32* %14
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i8, i8* %205, i64 %207
%209 = load i8, i8* %208
%210 = sext i8 %209 to i32
%211 = sub nsw i32 %210, 48
%212 = sext i32 %211 to i64
store i64 %212, i64* %19
%213 = load i64, i64* %19
%214 = icmp sge i64 %213, 0
br i1 %214, label %215, label %223
215: ; preds = %204
%216 = load i64, i64* %19
%217 = icmp sle i64 %216, 9
br i1 %217, label %218, label %223
218: ; preds = %215
%219 = load i64, i64* %20
%220 = mul nsw i64 %219, 10
%221 = load i64, i64* %19
%222 = add nsw i64 %220, %221
store i64 %222, i64* %20
br label %223
223: ; preds = %218, %215, %204
br label %224
224: ; preds = %223
%225 = load i32, i32* %14
%226 = add nsw i32 %225, 1
store i32 %226, i32* %14
br label %200
227: ; preds = %200
br label %228
228: ; preds = %227, %191
%229 = load i8*, i8** %24
%230 = load i32, i32* %14
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i8, i8* %229, i64 %231
%233 = load i8, i8* %232
%234 = sext i8 %233 to i32
%235 = sub nsw i32 %234, 48
%236 = sext i32 %235 to i64
store i64 %236, i64* %19
%237 = load i64, i64* %19
%238 = icmp sge i64 %237, 0
br i1 %238, label %239, label %265
239: ; preds = %228
%240 = load i64, i64* %19
%241 = icmp sle i64 %240, 9
br i1 %241, label %242, label %265
242: ; preds = %239
%243 = load i32*, i32** %6
%244 = load i32, i32* %11
%245 = load i32, i32* %12
%246 = load i32, i32* %15
%247 = mul nsw i32 %245, %246
%248 = add nsw i32 %244, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %243, i64 %249
%251 = load i32, i32* %250
%252 = mul nsw i32 %251, 10
%253 = sext i32 %252 to i64
%254 = load i64, i64* %19
%255 = add nsw i64 %253, %254
%256 = trunc i64 %255 to i32
%257 = load i32*, i32** %6
%258 = load i32, i32* %11
%259 = load i32, i32* %12
%260 = load i32, i32* %15
%261 = mul nsw i32 %259, %260
%262 = add nsw i32 %258, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %257, i64 %263
store i32 %256, i32* %264
br label %265
265: ; preds = %242, %239, %228
br label %266
266: ; preds = %265
%267 = load i32, i32* %14
%268 = add nsw i32 %267, 1
store i32 %268, i32* %14
br label %149
269: ; preds = %149
%270 = load i64, i64* %20
%271 = icmp slt i64 %270, 1
br i1 %271, label %272, label %273
272: ; preds = %269
store i64 2, i64* %20
br label %273
273: ; preds = %272, %269
%274 = load i32, i32* %12
%275 = icmp eq i32 %274, 0
br i1 %275, label %276, label %278
276: ; preds = %273
%277 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %3
br label %580
278: ; preds = %273
%279 = load i32, i32* %12
%280 = sub nsw i32 %279, 1
%281 = sext i32 %280 to i64
store i64 %281, i64* %18
br label %282
282: ; preds = %570, %278
%283 = load i64, i64* %18
%284 = icmp sge i64 %283, 0
br i1 %284, label %285, label %573
285: ; preds = %282
store i32 0, i32* %11
br label %286
286: ; preds = %322, %285
%287 = load i32, i32* %11
%288 = sext i32 %287 to i64
%289 = load i64, i64* %18
%290 = icmp sle i64 %288, %289
br i1 %290, label %291, label %325
291: ; preds = %286
%292 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %12
br label %293
293: ; preds = %308, %291
%294 = load i32, i32* %12
%295 = load i32, i32* %8
%296 = icmp slt i32 %294, %295
br i1 %296, label %297, label %311
297: ; preds = %293
%298 = load i32*, i32** %6
%299 = load i32, i32* %12
%300 = load i32, i32* %11
%301 = load i32, i32* %15
%302 = mul nsw i32 %300, %301
%303 = add nsw i32 %299, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds i32, i32* %298, i64 %304
%306 = load i32, i32* %305
%307 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i32 %306)
br label %308
308: ; preds = %297
%309 = load i32, i32* %12
%310 = add nsw i32 %309, 1
store i32 %310, i32* %12
br label %293
311: ; preds = %293
%312 = load i32*, i32** %6
%313 = load i32, i32* %8
%314 = load i32, i32* %11
%315 = load i32, i32* %15
%316 = mul nsw i32 %314, %315
%317 = add nsw i32 %313, %316
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds i32, i32* %312, i64 %318
%320 = load i32, i32* %319
%321 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %320)
br label %322
322: ; preds = %311
%323 = load i32, i32* %11
%324 = add nsw i32 %323, 1
store i32 %324, i32* %11
br label %286
325: ; preds = %286
%326 = load i64, i64* %20
%327 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i64 %326)
%328 = load i32, i32* %17
%329 = icmp eq i32 %328, 2
br i1 %329, label %330, label %333
330: ; preds = %325
%331 = load i64, i64* %20
%332 = add nsw i64 %331, 1
store i64 %332, i64* %20
br label %333
333: ; preds = %330, %325
%334 = load i32, i32* %17
%335 = icmp eq i32 %334, 3
br i1 %335, label %336, label %340
336: ; preds = %333
%337 = load i64, i64* %20
%338 = load i64, i64* %20
%339 = mul nsw i64 %338, %337
store i64 %339, i64* %20
br label %340
340: ; preds = %336, %333
%341 = load i32*, i32** %6
%342 = load i64, i64* %18
%343 = load i32, i32* %15
%344 = sext i32 %343 to i64
%345 = mul nsw i64 %342, %344
%346 = getelementptr inbounds i32, i32* %341, i64 %345
%347 = load i32, i32* %346
%348 = icmp eq i32 %347, 0
br i1 %348, label %349, label %356
349: ; preds = %340
store i32 0, i32* %9
%350 = load i32, i32* %17
%351 = icmp eq i32 %350, 4
br i1 %351, label %352, label %355
352: ; preds = %349
%353 = load i64, i64* %20
%354 = add nsw i64 %353, 1
store i64 %354, i64* %20
br label %355
355: ; preds = %352, %349
br label %479
356: ; preds = %340
%357 = load i32, i32* %8
%358 = add nsw i32 %357, 1
store i32 %358, i32* %14
store i32 0, i32* %9
store i32 0, i32* %12
br label %359
359: ; preds = %380, %356
%360 = load i32, i32* %12
%361 = load i32, i32* %8
%362 = icmp sle i32 %360, %361
br i1 %362, label %363, label %383
363: ; preds = %359
%364 = load i32*, i32** %6
%365 = load i32, i32* %12
%366 = sext i32 %365 to i64
%367 = load i64, i64* %18
%368 = load i32, i32* %15
%369 = sext i32 %368 to i64
%370 = mul nsw i64 %367, %369
%371 = add nsw i64 %366, %370
%372 = getelementptr inbounds i32, i32* %364, i64 %371
%373 = load i32, i32* %372
%374 = icmp eq i32 %373, 0
br i1 %374, label %375, label %379
375: ; preds = %363
%376 = load i32, i32* %12
store i32 %376, i32* %14
%377 = load i32, i32* %8
%378 = add nsw i32 %377, 1
store i32 %378, i32* %12
br label %379
379: ; preds = %375, %363
br label %380
380: ; preds = %379
%381 = load i32, i32* %12
%382 = add nsw i32 %381, 1
store i32 %382, i32* %12
br label %359
383: ; preds = %359
store i64 0, i64* %19
br label %384
384: ; preds = %475, %383
%385 = load i64, i64* %19
%386 = load i64, i64* %18
%387 = icmp sle i64 %385, %386
br i1 %387, label %388, label %478
388: ; preds = %384
store i32 1, i32* %10
store i32 0, i32* %13
br label %389
389: ; preds = %419, %388
%390 = load i32, i32* %13
%391 = load i32, i32* %14
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %422
393: ; preds = %389
%394 = load i32*, i32** %6
%395 = load i32, i32* %13
%396 = sext i32 %395 to i64
%397 = load i64, i64* %18
%398 = load i64, i64* %19
%399 = sub nsw i64 %397, %398
%400 = load i32, i32* %15
%401 = sext i32 %400 to i64
%402 = mul nsw i64 %399, %401
%403 = add nsw i64 %396, %402
%404 = getelementptr inbounds i32, i32* %394, i64 %403
%405 = load i32, i32* %404
%406 = load i32*, i32** %6
%407 = load i32, i32* %13
%408 = sext i32 %407 to i64
%409 = load i64, i64* %18
%410 = load i32, i32* %15
%411 = sext i32 %410 to i64
%412 = mul nsw i64 %409, %411
%413 = add nsw i64 %408, %412
%414 = getelementptr inbounds i32, i32* %406, i64 %413
%415 = load i32, i32* %414
%416 = icmp sge i32 %405, %415
br i1 %416, label %417, label %418
417: ; preds = %393
store i32 0, i32* %10
br label %418
418: ; preds = %417, %393
br label %419
419: ; preds = %418
%420 = load i32, i32* %13
%421 = add nsw i32 %420, 1
store i32 %421, i32* %13
br label %389
422: ; preds = %389
%423 = load i32, i32* %10
%424 = icmp ne i32 %423, 0
br i1 %424, label %425, label %474
425: ; preds = %422
store i32 0, i32* %13
br label %426
426: ; preds = %466, %425
%427 = load i32, i32* %13
%428 = load i32, i32* %8
%429 = icmp sle i32 %427, %428
br i1 %429, label %430, label %469
430: ; preds = %426
%431 = load i32, i32* %13
%432 = load i32, i32* %14
%433 = sub nsw i32 %432, 1
%434 = icmp slt i32 %431, %433
br i1 %434, label %435, label %459
435: ; preds = %430
%436 = load i32*, i32** %6
%437 = load i32, i32* %13
%438 = sext i32 %437 to i64
%439 = load i64, i64* %18
%440 = load i32, i32* %15
%441 = sext i32 %440 to i64
%442 = mul nsw i64 %439, %441
%443 = add nsw i64 %438, %442
%444 = getelementptr inbounds i32, i32* %436, i64 %443
%445 = load i32, i32* %444
%446 = load i32*, i32** %6
%447 = load i32, i32* %13
%448 = sext i32 %447 to i64
%449 = load i64, i64* %18
%450 = load i64, i64* %19
%451 = sub nsw i64 %449, %450
%452 = load i32, i32* %15
%453 = sext i32 %452 to i64
%454 = mul nsw i64 %451, %453
%455 = add nsw i64 %448, %454
%456 = getelementptr inbounds i32, i32* %446, i64 %455
%457 = load i32, i32* %456
%458 = sub nsw i32 %445, %457
br label %460
459: ; preds = %430
br label %460
460: ; preds = %459, %435
%461 = phi i32 [ %458, %435 ], [ 0, %459 ]
%462 = load i32*, i32** %7
%463 = load i32, i32* %13
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
store i32 %461, i32* %465
br label %466
466: ; preds = %460
%467 = load i32, i32* %13
%468 = add nsw i32 %467, 1
store i32 %468, i32* %13
br label %426
469: ; preds = %426
%470 = load i64, i64* %19
%471 = trunc i64 %470 to i32
store i32 %471, i32* %9
%472 = load i64, i64* %18
%473 = add nsw i64 %472, 1
store i64 %473, i64* %19
br label %474
474: ; preds = %469, %422
br label %475
475: ; preds = %474
%476 = load i64, i64* %19
%477 = add nsw i64 %476, 1
store i64 %477, i64* %19
br label %384
478: ; preds = %384
br label %479
479: ; preds = %478, %355
%480 = load i32, i32* %17
%481 = icmp eq i32 %480, 4
br i1 %481, label %482, label %490
482: ; preds = %479
%483 = load i64, i64* %18
%484 = load i32, i32* %9
%485 = sext i32 %484 to i64
%486 = load i64, i64* %20
%487 = sub nsw i64 %486, 1
%488 = mul nsw i64 %485, %487
%489 = add nsw i64 %483, %488
br label %497
490: ; preds = %479
%491 = load i64, i64* %18
%492 = load i32, i32* %9
%493 = sext i32 %492 to i64
%494 = load i64, i64* %20
%495 = mul nsw i64 %493, %494
%496 = add nsw i64 %491, %495
br label %497
497: ; preds = %490, %482
%498 = phi i64 [ %489, %482 ], [ %496, %490 ]
store i64 %498, i64* %19
%499 = load i64, i64* %19
%500 = load i64, i64* %21
%501 = icmp sgt i64 %499, %500
br i1 %501, label %502, label %509
502: ; preds = %497
%503 = load i64, i64* %21
%504 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.8, i64 0, i64 0), i64 %503)
%505 = load i32*, i32** %6
%506 = call i32 @free(i32* %505)
%507 = load i32*, i32** %7
%508 = call i32 @free(i32* %507)
store i32 0, i32* %3
br label %580
509: ; preds = %497
%510 = load i64, i64* %23
%511 = icmp ne i64 %510, 0
br i1 %511, label %512, label %524
512: ; preds = %509
%513 = load i64, i64* %22
%514 = add nsw i64 %513, 1
store i64 %514, i64* %22
%515 = load i64, i64* %23
%516 = icmp sge i64 %513, %515
br i1 %516, label %517, label %524
517: ; preds = %512
%518 = load i64, i64* %23
%519 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.9, i64 0, i64 0), i64 %518)
%520 = load i32*, i32** %6
%521 = call i32 @free(i32* %520)
%522 = load i32*, i32** %7
%523 = call i32 @free(i32* %522)
store i32 0, i32* %3
br label %580
524: ; preds = %512, %509
br label %525
525: ; preds = %566, %524
%526 = load i64, i64* %18
%527 = load i64, i64* %19
%528 = icmp slt i64 %526, %527
br i1 %528, label %529, label %569
529: ; preds = %525
store i32 0, i32* %13
br label %530
530: ; preds = %563, %529
%531 = load i32, i32* %13
%532 = load i32, i32* %8
%533 = icmp sle i32 %531, %532
br i1 %533, label %534, label %566
534: ; preds = %530
%535 = load i32*, i32** %6
%536 = load i32, i32* %13
%537 = sext i32 %536 to i64
%538 = load i64, i64* %18
%539 = load i32, i32* %9
%540 = sext i32 %539 to i64
%541 = sub nsw i64 %538, %540
%542 = load i32, i32* %15
%543 = sext i32 %542 to i64
%544 = mul nsw i64 %541, %543
%545 = add nsw i64 %537, %544
%546 = getelementptr inbounds i32, i32* %535, i64 %545
%547 = load i32, i32* %546
%548 = load i32*, i32** %7
%549 = load i32, i32* %13
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i32, i32* %548, i64 %550
%552 = load i32, i32* %551
%553 = add nsw i32 %547, %552
%554 = load i32*, i32** %6
%555 = load i32, i32* %13
%556 = sext i32 %555 to i64
%557 = load i64, i64* %18
%558 = load i32, i32* %15
%559 = sext i32 %558 to i64
%560 = mul nsw i64 %557, %559
%561 = add nsw i64 %556, %560
%562 = getelementptr inbounds i32, i32* %554, i64 %561
store i32 %553, i32* %562
br label %563
563: ; preds = %534
%564 = load i32, i32* %13
%565 = add nsw i32 %564, 1
store i32 %565, i32* %13
br label %530
566: ; preds = %530
%567 = load i64, i64* %18
%568 = add nsw i64 %567, 1
store i64 %568, i64* %18
br label %525
569: ; preds = %525
br label %570
570: ; preds = %569
%571 = load i64, i64* %18
%572 = add nsw i64 %571, -1
store i64 %572, i64* %18
br label %282
573: ; preds = %282
%574 = load i64, i64* %20
%575 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i64 %574)
%576 = load i32*, i32** %6
%577 = call i32 @free(i32* %576)
%578 = load i32*, i32** %7
%579 = call i32 @free(i32* %578)
store i32 0, i32* %3
br label %580
580: ; preds = %573, %517, %502, %276, %27
%581 = load i32, i32* %3
ret i32 %581
}

LLVM IR (-O2):
@.str = [34 x i8] c"Usage: %s ini [max] [opt] [step]\0A\00"
@.str.5 = [4 x i8] c"%d,\00"
@.str.6 = [4 x i8] c"%d)\00"
@.str.7 = [7 x i8] c"[%ld]\0A\00"
@.str.8 = [46 x i8] c"Length of sequence exceeds %ld at next step.\0A\00"
@.str.9 = [46 x i8] c"Maximum step of calculation %ld has reached.\0A\00"
@.str.10 = [19 x i8] c"Finished. n = %ld\0A\00"
@str = [27 x i8] c"Invalid initial parameter.\00"
@str.11 = [19 x i8] c"Allocation failed.\00"
@str.12 = [64 x i8] c"See comment in the source: http://gyafun.jp/ln/basmat.cgi?ini=s\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp slt i32 %0, 2
br i1 %3, label %4, label %8
4: ; preds = %2
%5 = load i8*, i8** %1
%6 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i8* %5)
%7 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str.12, i64 0, i64 0))
br label %605
8: ; preds = %2
%9 = getelementptr inbounds i8*, i8** %1, i64 1
%10 = load i8*, i8** %9
%11 = icmp eq i32 %0, 2
br i1 %11, label %29, label %12
12: ; preds = %8
%13 = getelementptr inbounds i8*, i8** %1, i64 2
%14 = load i8*, i8** %13
%15 = tail call i32 @atol(i8* %14)
%16 = sext i32 %15 to i64
%17 = icmp sgt i64 %16, 1
%18 = select i1 %17, i64 %16, i64 1
%19 = icmp ugt i32 %0, 3
br i1 %19, label %20, label %29
20: ; preds = %12
%21 = getelementptr inbounds i8*, i8** %1, i64 3
%22 = load i8*, i8** %21
%23 = tail call i32 @atoi(i8* %22)
%24 = icmp eq i32 %0, 4
br i1 %24, label %29, label %25
25: ; preds = %20
%26 = getelementptr inbounds i8*, i8** %1, i64 4
%27 = load i8*, i8** %26
%28 = tail call i32 @atoi(i8* %27)
br label %29
29: ; preds = %8, %12, %20, %25
%30 = phi i32 [ %23, %25 ], [ %23, %20 ], [ 1, %12 ], [ 1, %8 ]
%31 = phi i64 [ %18, %25 ], [ %18, %20 ], [ %18, %12 ], [ 20, %8 ]
%32 = phi i32 [ %28, %25 ], [ 0, %20 ], [ 0, %12 ], [ 0, %8 ]
%33 = icmp sgt i32 %32, 0
%34 = select i1 %33, i32 %32, i32 0
%35 = zext i32 %34 to i64
%36 = tail call i32 @strlen(i8* %10)
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %57
38: ; preds = %29, %38
%39 = phi i32 [ %52, %38 ], [ 0, %29 ]
%40 = phi i32 [ %55, %38 ], [ 0, %29 ]
%41 = phi i32 [ %50, %38 ], [ 0, %29 ]
%42 = sext i32 %40 to i64
%43 = getelementptr inbounds i8, i8* %10, i64 %42
%44 = load i8, i8* %43
%45 = icmp eq i8 %44, 44
%46 = zext i1 %45 to i32
%47 = add nsw i32 %41, %46
%48 = icmp eq i8 %44, 41
%49 = icmp slt i32 %39, %47
%50 = select i1 %48, i32 0, i32 %47
%51 = select i1 %48, i1 %49, i1 false
%52 = select i1 %51, i32 %47, i32 %39
%53 = icmp eq i8 %44, 91
%54 = select i1 %53, i32 %36, i32 %40
%55 = add nsw i32 %54, 1
%56 = icmp slt i32 %55, %36
br i1 %56, label %38, label %57
57: ; preds = %38, %29
%58 = phi i32 [ 0, %29 ], [ %52, %38 ]
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = shl nsw i64 %60, 2
%62 = mul i64 %61, %31
%63 = trunc i64 %62 to i32
%64 = tail call i32* @malloc(i32 %63)
%65 = trunc i64 %61 to i32
%66 = tail call i32* @malloc(i32 %65)
%67 = icmp eq i32* %64, null
%68 = icmp eq i32* %66, null
%69 = or i1 %67, %68
br i1 %69, label %70, label %73
70: ; preds = %57
%71 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @str.11, i64 0, i64 0))
%72 = tail call i32 @exit(i32 -1)
unreachable
73: ; preds = %57
store i32 0, i32* %64
br i1 %37, label %74, label %175
74: ; preds = %73
%75 = sext i32 %36 to i64
%76 = getelementptr inbounds i8, i8* %10, i64 %75
%77 = add nsw i64 %75, -2
br label %78
78: ; preds = %74, %166
%79 = phi i64 [ %167, %166 ], [ 0, %74 ]
%80 = phi i32 [ %171, %166 ], [ 0, %74 ]
%81 = phi i32 [ %170, %166 ], [ 0, %74 ]
%82 = phi i32 [ %169, %166 ], [ 0, %74 ]
%83 = sext i32 %80 to i64
%84 = getelementptr inbounds i8, i8* %10, i64 %83
%85 = load i8, i8* %84
switch i8 %85, label %150 [
i8 44, label %112
i8 41, label %118
i8 91, label %86
]
86: ; preds = %78
%87 = icmp slt i32 %80, %36
br i1 %87, label %88, label %166
88: ; preds = %86
%89 = add nsw i64 %83, 1
%90 = icmp eq i64 %89, %75
br i1 %90, label %147, label %91
91: ; preds = %88
%92 = xor i64 %83, -1
%93 = add nsw i64 %92, %75
%94 = and i64 %93, 1
%95 = icmp eq i64 %94, 0
br i1 %95, label %107, label %96
96: ; preds = %91
%97 = getelementptr inbounds i8, i8* %10, i64 %89
%98 = load i8, i8* %97
%99 = add i8 %98, -48
%100 = icmp ult i8 %99, 10
%101 = sext i8 %98 to i64
%102 = mul nsw i64 %79, 10
%103 = add i64 %102, -48
%104 = add i64 %103, %101
%105 = select i1 %100, i64 %104, i64 %79
%106 = add nsw i64 %83, 2
br label %107
107: ; preds = %96, %91
%108 = phi i64 [ undef, %91 ], [ %105, %96 ]
%109 = phi i64 [ %89, %91 ], [ %106, %96 ]
%110 = phi i64 [ %79, %91 ], [ %105, %96 ]
%111 = icmp eq i64 %77, %83
br i1 %111, label %147, label %123
112: ; preds = %78
%113 = add nsw i32 %82, 1
%114 = mul nsw i32 %81, %59
%115 = add nsw i32 %114, %113
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %64, i64 %116
store i32 0, i32* %117
br label %166
118: ; preds = %78
%119 = add nsw i32 %81, 1
%120 = mul nsw i32 %119, %59
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %64, i64 %121
store i32 0, i32* %122
br label %166
123: ; preds = %107, %123
%124 = phi i64 [ %145, %123 ], [ %109, %107 ]
%125 = phi i64 [ %144, %123 ], [ %110, %107 ]
%126 = getelementptr inbounds i8, i8* %10, i64 %124
%127 = load i8, i8* %126
%128 = add i8 %127, -48
%129 = icmp ult i8 %128, 10
%130 = sext i8 %127 to i64
%131 = mul nsw i64 %125, 10
%132 = add i64 %131, -48
%133 = add i64 %132, %130
%134 = select i1 %129, i64 %133, i64 %125
%135 = add nsw i64 %124, 1
%136 = getelementptr inbounds i8, i8* %10, i64 %135
%137 = load i8, i8* %136
%138 = add i8 %137, -48
%139 = icmp ult i8 %138, 10
%140 = sext i8 %137 to i64
%141 = mul nsw i64 %134, 10
%142 = add i64 %141, -48
%143 = add i64 %142, %140
%144 = select i1 %139, i64 %143, i64 %134
%145 = add nsw i64 %124, 2
%146 = icmp eq i64 %145, %75
br i1 %146, label %147, label %123
147: ; preds = %107, %123, %88
%148 = phi i64 [ %79, %88 ], [ %108, %107 ], [ %144, %123 ]
%149 = load i8, i8* %76
br label %150
150: ; preds = %147, %78
%151 = phi i8 [ %149, %147 ], [ %85, %78 ]
%152 = phi i32 [ %36, %147 ], [ %80, %78 ]
%153 = phi i64 [ %148, %147 ], [ %79, %78 ]
%154 = add i8 %151, -48
%155 = icmp ult i8 %154, 10
br i1 %155, label %156, label %166
156: ; preds = %150
%157 = zext i8 %151 to i32
%158 = add nsw i32 %157, -48
%159 = mul nsw i32 %81, %59
%160 = add nsw i32 %82, %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %64, i64 %161
%163 = load i32, i32* %162
%164 = mul nsw i32 %163, 10
%165 = add i32 %158, %164
store i32 %165, i32* %162
br label %166
166: ; preds = %112, %118, %86, %150, %156
%167 = phi i64 [ %153, %150 ], [ %153, %156 ], [ %79, %86 ], [ %79, %118 ], [ %79, %112 ]
%168 = phi i32 [ %152, %150 ], [ %152, %156 ], [ %80, %86 ], [ %80, %118 ], [ %80, %112 ]
%169 = phi i32 [ %82, %150 ], [ %82, %156 ], [ %82, %86 ], [ 0, %118 ], [ %113, %112 ]
%170 = phi i32 [ %81, %150 ], [ %81, %156 ], [ %81, %86 ], [ %119, %118 ], [ %81, %112 ]
%171 = add nsw i32 %168, 1
%172 = icmp slt i32 %171, %36
br i1 %172, label %78, label %173
173: ; preds = %166
%174 = icmp eq i32 %170, 0
br i1 %174, label %175, label %177
175: ; preds = %73, %173
%176 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str, i64 0, i64 0))
br label %605
177: ; preds = %173
%178 = icmp slt i64 %167, 1
%179 = select i1 %178, i64 2, i64 %167
%180 = icmp sgt i32 %170, 0
br i1 %180, label %181, label %600
181: ; preds = %177
%182 = add nsw i32 %170, -1
%183 = zext i32 %182 to i64
%184 = icmp sgt i32 %58, 0
%185 = icmp eq i32 %30, 2
%186 = zext i1 %185 to i64
%187 = icmp eq i32 %30, 3
%188 = icmp slt i32 %58, 0
%189 = icmp eq i32 %30, 4
%190 = zext i1 %189 to i64
%191 = sext i1 %189 to i64
%192 = sext i32 %58 to i64
%193 = zext i32 %58 to i64
%194 = zext i32 %59 to i64
%195 = zext i32 %59 to i64
%196 = and i64 %194, 4294967288
%197 = add nsw i64 %196, -8
%198 = lshr exact i64 %197, 3
%199 = add nuw nsw i64 %198, 1
%200 = and i64 %194, 1
%201 = icmp eq i32 %58, 0
%202 = and i64 %194, 4294967294
%203 = icmp eq i64 %200, 0
%204 = icmp ult i32 %59, 8
%205 = and i64 %194, 4294967288
%206 = and i64 %199, 1
%207 = icmp eq i64 %197, 0
%208 = and i64 %199, 4611686018427387902
%209 = icmp eq i64 %206, 0
%210 = icmp eq i64 %205, %194
%211 = and i64 %194, 1
%212 = icmp eq i64 %211, 0
%213 = sub nsw i64 0, %194
br label %214
214: ; preds = %596, %181
%215 = phi i64 [ 0, %181 ], [ %463, %596 ]
%216 = phi i64 [ %179, %181 ], [ %444, %596 ]
%217 = phi i64 [ %183, %181 ], [ %598, %596 ]
br label %218
218: ; preds = %214, %230
%219 = phi i64 [ 0, %214 ], [ %235, %230 ]
%220 = tail call i32 @putchar(i32 40)
%221 = mul nsw i64 %219, %60
br i1 %184, label %222, label %230
222: ; preds = %218, %222
%223 = phi i64 [ %228, %222 ], [ 0, %218 ]
%224 = add nsw i64 %223, %221
%225 = getelementptr inbounds i32, i32* %64, i64 %224
%226 = load i32, i32* %225
%227 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i32 %226)
%228 = add nuw nsw i64 %223, 1
%229 = icmp eq i64 %228, %193
br i1 %229, label %230, label %222
230: ; preds = %222, %218
%231 = add nsw i64 %221, %192
%232 = getelementptr inbounds i32, i32* %64, i64 %231
%233 = load i32, i32* %232
%234 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i32 %233)
%235 = add nuw i64 %219, 1
%236 = and i64 %235, 4294967295
%237 = icmp slt i64 %217, %236
br i1 %237, label %238, label %218
238: ; preds = %230
%239 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i64 %216)
%240 = add nsw i64 %216, %186
%241 = select i1 %187, i64 %240, i64 1
%242 = mul nsw i64 %241, %240
%243 = mul nsw i64 %217, %60
%244 = getelementptr inbounds i32, i32* %64, i64 %243
%245 = load i32, i32* %244
%246 = icmp eq i32 %245, 0
br i1 %246, label %248, label %247
247: ; preds = %238
br i1 %188, label %250, label %268
248: ; preds = %238
%249 = add nsw i64 %242, %190
br label %442
250: ; preds = %268, %247
%251 = phi i32 [ %59, %247 ], [ %277, %268 ]
%252 = icmp sgt i32 %251, 0
%253 = add nsw i32 %251, -1
%254 = add nuw nsw i64 %217, 1
%255 = sext i32 %253 to i64
%256 = zext i32 %251 to i64
%257 = and i64 %256, 4294967288
%258 = add nsw i64 %257, -8
%259 = lshr exact i64 %258, 3
%260 = add nuw nsw i64 %259, 1
%261 = icmp ult i32 %251, 8
%262 = and i64 %256, 4294967288
%263 = and i64 %260, 1
%264 = icmp eq i64 %258, 0
%265 = and i64 %260, 4611686018427387902
%266 = icmp eq i64 %263, 0
%267 = icmp eq i64 %262, %256
br label %280
268: ; preds = %247, %268
%269 = phi i32 [ %277, %268 ], [ %59, %247 ]
%270 = phi i32 [ %278, %268 ], [ 0, %247 ]
%271 = sext i32 %270 to i64
%272 = add nsw i64 %243, %271
%273 = getelementptr inbounds i32, i32* %64, i64 %272
%274 = load i32, i32* %273
%275 = icmp eq i32 %274, 0
%276 = select i1 %275, i32 %59, i32 %270
%277 = select i1 %275, i32 %270, i32 %269
%278 = add nsw i32 %276, 1
%279 = icmp slt i32 %276, %58
br i1 %279, label %268, label %250
280: ; preds = %250, %437
%281 = phi i64 [ 0, %250 ], [ %440, %437 ]
%282 = phi i32 [ 0, %250 ], [ %438, %437 ]
br i1 %252, label %283, label %385
283: ; preds = %280
%284 = sub nsw i64 %217, %281
%285 = mul nsw i64 %284, %60
br i1 %261, label %366, label %286
286: ; preds = %283
br i1 %264, label %332, label %287
287: ; preds = %286, %287
%288 = phi i64 [ %329, %287 ], [ 0, %286 ]
%289 = phi <4 x i32> [ %326, %287 ], [ <i32 1, i32 1, i32 1, i32 1>, %286 ]
%290 = phi <4 x i32> [ %328, %287 ], [ <i32 1, i32 1, i32 1, i32 1>, %286 ]
%291 = phi i64 [ %330, %287 ], [ 0, %286 ]
%292 = add nsw i64 %285, %288
%293 = getelementptr inbounds i32, i32* %64, i64 %292
%294 = bitcast i32* %293 to <4 x i32>*
%295 = load <4 x i32>, <4 x i32>* %294
%296 = getelementptr inbounds i32, i32* %293, i64 4
%297 = bitcast i32* %296 to <4 x i32>*
%298 = load <4 x i32>, <4 x i32>* %297
%299 = add nsw i64 %243, %288
%300 = getelementptr inbounds i32, i32* %64, i64 %299
%301 = bitcast i32* %300 to <4 x i32>*
%302 = load <4 x i32>, <4 x i32>* %301
%303 = getelementptr inbounds i32, i32* %300, i64 4
%304 = bitcast i32* %303 to <4 x i32>*
%305 = load <4 x i32>, <4 x i32>* %304
%306 = icmp slt <4 x i32> %295, %302
%307 = icmp slt <4 x i32> %298, %305
%308 = or i64 %288, 8
%309 = add nsw i64 %285, %308
%310 = getelementptr inbounds i32, i32* %64, i64 %309
%311 = bitcast i32* %310 to <4 x i32>*
%312 = load <4 x i32>, <4 x i32>* %311
%313 = getelementptr inbounds i32, i32* %310, i64 4
%314 = bitcast i32* %313 to <4 x i32>*
%315 = load <4 x i32>, <4 x i32>* %314
%316 = add nsw i64 %243, %308
%317 = getelementptr inbounds i32, i32* %64, i64 %316
%318 = bitcast i32* %317 to <4 x i32>*
%319 = load <4 x i32>, <4 x i32>* %318
%320 = getelementptr inbounds i32, i32* %317, i64 4
%321 = bitcast i32* %320 to <4 x i32>*
%322 = load <4 x i32>, <4 x i32>* %321
%323 = icmp slt <4 x i32> %312, %319
%324 = icmp slt <4 x i32> %315, %322
%325 = select <4 x i1> %323, <4 x i1> %306, <4 x i1> zeroinitializer
%326 = select <4 x i1> %325, <4 x i32> %289, <4 x i32> zeroinitializer
%327 = select <4 x i1> %324, <4 x i1> %307, <4 x i1> zeroinitializer
%328 = select <4 x i1> %327, <4 x i32> %290, <4 x i32> zeroinitializer
%329 = add nuw i64 %288, 16
%330 = add i64 %291, 2
%331 = icmp eq i64 %330, %265
br i1 %331, label %332, label %287
332: ; preds = %287, %286
%333 = phi <4 x i32> [ undef, %286 ], [ %326, %287 ]
%334 = phi <4 x i32> [ undef, %286 ], [ %328, %287 ]
%335 = phi i64 [ 0, %286 ], [ %329, %287 ]
%336 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %286 ], [ %326, %287 ]
%337 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %286 ], [ %328, %287 ]
br i1 %266, label %357, label %338
338: ; preds = %332
%339 = add nsw i64 %285, %335
%340 = getelementptr inbounds i32, i32* %64, i64 %339
%341 = bitcast i32* %340 to <4 x i32>*
%342 = load <4 x i32>, <4 x i32>* %341
%343 = getelementptr inbounds i32, i32* %340, i64 4
%344 = bitcast i32* %343 to <4 x i32>*
%345 = load <4 x i32>, <4 x i32>* %344
%346 = add nsw i64 %243, %335
%347 = getelementptr inbounds i32, i32* %64, i64 %346
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = getelementptr inbounds i32, i32* %347, i64 4
%351 = bitcast i32* %350 to <4 x i32>*
%352 = load <4 x i32>, <4 x i32>* %351
%353 = icmp slt <4 x i32> %342, %349
%354 = icmp slt <4 x i32> %345, %352
%355 = select <4 x i1> %353, <4 x i32> %336, <4 x i32> zeroinitializer
%356 = select <4 x i1> %354, <4 x i32> %337, <4 x i32> zeroinitializer
br label %357
357: ; preds = %332, %338
%358 = phi <4 x i32> [ %333, %332 ], [ %355, %338 ]
%359 = phi <4 x i32> [ %334, %332 ], [ %356, %338 ]
%360 = icmp eq <4 x i32> %358, <i32 1, i32 1, i32 1, i32 1>
%361 = select <4 x i1> %360, <4 x i32> %359, <4 x i32> %358
%362 = icmp ne <4 x i32> %361, <i32 1, i32 1, i32 1, i32 1>
%363 = bitcast <4 x i1> %362 to i4
%364 = icmp eq i4 %363, 0
%365 = zext i1 %364 to i32
br i1 %267, label %382, label %366
366: ; preds = %283, %357
%367 = phi i64 [ 0, %283 ], [ %262, %357 ]
%368 = phi i32 [ 1, %283 ], [ %365, %357 ]
br label %369
369: ; preds = %366, %369
%370 = phi i64 [ %380, %369 ], [ %367, %366 ]
%371 = phi i32 [ %379, %369 ], [ %368, %366 ]
%372 = add nsw i64 %285, %370
%373 = getelementptr inbounds i32, i32* %64, i64 %372
%374 = load i32, i32* %373
%375 = add nsw i64 %243, %370
%376 = getelementptr inbounds i32, i32* %64, i64 %375
%377 = load i32, i32* %376
%378 = icmp slt i32 %374, %377
%379 = select i1 %378, i32 %371, i32 0
%380 = add nuw nsw i64 %370, 1
%381 = icmp eq i64 %380, %256
br i1 %381, label %382, label %369
382: ; preds = %369, %357
%383 = phi i32 [ %365, %357 ], [ %379, %369 ]
%384 = icmp eq i32 %383, 0
br i1 %384, label %437, label %385
385: ; preds = %280, %382
br i1 %188, label %435, label %386
386: ; preds = %385
%387 = sub nsw i64 %217, %281
%388 = mul nsw i64 %387, %60
br i1 %201, label %420, label %389
389: ; preds = %386, %414
%390 = phi i64 [ %417, %414 ], [ 0, %386 ]
%391 = phi i64 [ %418, %414 ], [ 0, %386 ]
%392 = icmp slt i64 %390, %255
br i1 %392, label %393, label %401
393: ; preds = %389
%394 = add nsw i64 %243, %390
%395 = getelementptr inbounds i32, i32* %64, i64 %394
%396 = load i32, i32* %395
%397 = add nsw i64 %388, %390
%398 = getelementptr inbounds i32, i32* %64, i64 %397
%399 = load i32, i32* %398
%400 = sub nsw i32 %396, %399
br label %401
401: ; preds = %389, %393
%402 = phi i32 [ %400, %393 ], [ 0, %389 ]
%403 = getelementptr inbounds i32, i32* %66, i64 %390
store i32 %402, i32* %403
%404 = or i64 %390, 1
%405 = icmp slt i64 %404, %255
br i1 %405, label %406, label %414
406: ; preds = %401
%407 = add nsw i64 %243, %404
%408 = getelementptr inbounds i32, i32* %64, i64 %407
%409 = load i32, i32* %408
%410 = add nsw i64 %388, %404
%411 = getelementptr inbounds i32, i32* %64, i64 %410
%412 = load i32, i32* %411
%413 = sub nsw i32 %409, %412
br label %414
414: ; preds = %406, %401
%415 = phi i32 [ %413, %406 ], [ 0, %401 ]
%416 = getelementptr inbounds i32, i32* %66, i64 %404
store i32 %415, i32* %416
%417 = add nuw nsw i64 %390, 2
%418 = add i64 %391, 2
%419 = icmp eq i64 %418, %202
br i1 %419, label %420, label %389
420: ; preds = %414, %386
%421 = phi i64 [ 0, %386 ], [ %417, %414 ]
br i1 %203, label %435, label %422
422: ; preds = %420
%423 = icmp slt i64 %421, %255
br i1 %423, label %424, label %432
424: ; preds = %422
%425 = add nsw i64 %243, %421
%426 = getelementptr inbounds i32, i32* %64, i64 %425
%427 = load i32, i32* %426
%428 = add nsw i64 %388, %421
%429 = getelementptr inbounds i32, i32* %64, i64 %428
%430 = load i32, i32* %429
%431 = sub nsw i32 %427, %430
br label %432
432: ; preds = %424, %422
%433 = phi i32 [ %431, %424 ], [ 0, %422 ]
%434 = getelementptr inbounds i32, i32* %66, i64 %421
store i32 %433, i32* %434
br label %435
435: ; preds = %432, %420, %385
%436 = trunc i64 %281 to i32
br label %437
437: ; preds = %382, %435
%438 = phi i32 [ %436, %435 ], [ %282, %382 ]
%439 = phi i64 [ %254, %435 ], [ %281, %382 ]
%440 = add nsw i64 %439, 1
%441 = icmp sgt i64 %217, %439
br i1 %441, label %280, label %442
442: ; preds = %437, %248
%443 = phi i32 [ 0, %248 ], [ %438, %437 ]
%444 = phi i64 [ %249, %248 ], [ %242, %437 ]
%445 = zext i32 %443 to i64
%446 = add nsw i64 %444, %191
%447 = mul nsw i64 %446, %445
%448 = add nsw i64 %447, %217
%449 = icmp sgt i64 %448, %31
br i1 %449, label %450, label %454
450: ; preds = %442
%451 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.8, i64 0, i64 0), i64 %31)
%452 = tail call i32 @free(i32* %64)
%453 = tail call i32 @free(i32* %66)
br label %605
454: ; preds = %442
br i1 %33, label %455, label %462
455: ; preds = %454
%456 = add nsw i64 %215, 1
%457 = icmp slt i64 %215, %35
br i1 %457, label %462, label %458
458: ; preds = %455
%459 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.9, i64 0, i64 0), i64 %35)
%460 = tail call i32 @free(i32* %64)
%461 = tail call i32 @free(i32* %66)
br label %605
462: ; preds = %455, %454
%463 = phi i64 [ %456, %455 ], [ %215, %454 ]
%464 = icmp sgt i64 %447, 0
br i1 %464, label %465, label %596
465: ; preds = %462
%466 = getelementptr i32, i32* %64, i64 %243
%467 = add i64 %243, %194
%468 = getelementptr i32, i32* %64, i64 %467
%469 = sub i64 %217, %445
%470 = mul i64 %469, %60
%471 = getelementptr i32, i32* %64, i64 %470
%472 = add i64 %470, %194
%473 = getelementptr i32, i32* %64, i64 %472
%474 = icmp ult i32* %466, %473
%475 = icmp ult i32* %471, %468
%476 = and i1 %474, %475
br label %477
477: ; preds = %465, %593
%478 = phi i64 [ %217, %465 ], [ %594, %593 ]
br i1 %188, label %593, label %479
479: ; preds = %477
%480 = sub nsw i64 %478, %445
%481 = mul nsw i64 %480, %60
%482 = mul nsw i64 %478, %60
%483 = select i1 %204, i1 true, i1 %476
br i1 %483, label %556, label %484
484: ; preds = %479
br i1 %207, label %532, label %485
485: ; preds = %484, %485
%486 = phi i64 [ %529, %485 ], [ 0, %484 ]
%487 = phi i64 [ %530, %485 ], [ 0, %484 ]
%488 = add nsw i64 %481, %486
%489 = getelementptr inbounds i32, i32* %64, i64 %488
%490 = bitcast i32* %489 to <4 x i32>*
%491 = load <4 x i32>, <4 x i32>* %490
%492 = getelementptr inbounds i32, i32* %489, i64 4
%493 = bitcast i32* %492 to <4 x i32>*
%494 = load <4 x i32>, <4 x i32>* %493
%495 = getelementptr inbounds i32, i32* %66, i64 %486
%496 = bitcast i32* %495 to <4 x i32>*
%497 = load <4 x i32>, <4 x i32>* %496
%498 = getelementptr inbounds i32, i32* %495, i64 4
%499 = bitcast i32* %498 to <4 x i32>*
%500 = load <4 x i32>, <4 x i32>* %499
%501 = add nsw <4 x i32> %497, %491
%502 = add nsw <4 x i32> %500, %494
%503 = add nsw i64 %482, %486
%504 = getelementptr inbounds i32, i32* %64, i64 %503
%505 = bitcast i32* %504 to <4 x i32>*
store <4 x i32> %501, <4 x i32>* %505
%506 = getelementptr inbounds i32, i32* %504, i64 4
%507 = bitcast i32* %506 to <4 x i32>*
store <4 x i32> %502, <4 x i32>* %507
%508 = or i64 %486, 8
%509 = add nsw i64 %481, %508
%510 = getelementptr inbounds i32, i32* %64, i64 %509
%511 = bitcast i32* %510 to <4 x i32>*
%512 = load <4 x i32>, <4 x i32>* %511
%513 = getelementptr inbounds i32, i32* %510, i64 4
%514 = bitcast i32* %513 to <4 x i32>*
%515 = load <4 x i32>, <4 x i32>* %514
%516 = getelementptr inbounds i32, i32* %66, i64 %508
%517 = bitcast i32* %516 to <4 x i32>*
%518 = load <4 x i32>, <4 x i32>* %517
%519 = getelementptr inbounds i32, i32* %516, i64 4
%520 = bitcast i32* %519 to <4 x i32>*
%521 = load <4 x i32>, <4 x i32>* %520
%522 = add nsw <4 x i32> %518, %512
%523 = add nsw <4 x i32> %521, %515
%524 = add nsw i64 %482, %508
%525 = getelementptr inbounds i32, i32* %64, i64 %524
%526 = bitcast i32* %525 to <4 x i32>*
store <4 x i32> %522, <4 x i32>* %526
%527 = getelementptr inbounds i32, i32* %525, i64 4
%528 = bitcast i32* %527 to <4 x i32>*
store <4 x i32> %523, <4 x i32>* %528
%529 = add nuw i64 %486, 16
%530 = add i64 %487, 2
%531 = icmp eq i64 %530, %208
br i1 %531, label %532, label %485
532: ; preds = %485, %484
%533 = phi i64 [ 0, %484 ], [ %529, %485 ]
br i1 %209, label %555, label %534
534: ; preds = %532
%535 = add nsw i64 %481, %533
%536 = getelementptr inbounds i32, i32* %64, i64 %535
%537 = bitcast i32* %536 to <4 x i32>*
%538 = load <4 x i32>, <4 x i32>* %537
%539 = getelementptr inbounds i32, i32* %536, i64 4
%540 = bitcast i32* %539 to <4 x i32>*
%541 = load <4 x i32>, <4 x i32>* %540
%542 = getelementptr inbounds i32, i32* %66, i64 %533
%543 = bitcast i32* %542 to <4 x i32>*
%544 = load <4 x i32>, <4 x i32>* %543
%545 = getelementptr inbounds i32, i32* %542, i64 4
%546 = bitcast i32* %545 to <4 x i32>*
%547 = load <4 x i32>, <4 x i32>* %546
%548 = add nsw <4 x i32> %544, %538
%549 = add nsw <4 x i32> %547, %541
%550 = add nsw i64 %482, %533
%551 = getelementptr inbounds i32, i32* %64, i64 %550
%552 = bitcast i32* %551 to <4 x i32>*
store <4 x i32> %548, <4 x i32>* %552
%553 = getelementptr inbounds i32, i32* %551, i64 4
%554 = bitcast i32* %553 to <4 x i32>*
store <4 x i32> %549, <4 x i32>* %554
br label %555
555: ; preds = %532, %534
br i1 %210, label %593, label %556
556: ; preds = %479, %555
%557 = phi i64 [ 0, %479 ], [ %205, %555 ]
%558 = xor i64 %557, -1
br i1 %212, label %569, label %559
559: ; preds = %556
%560 = add nsw i64 %481, %557
%561 = getelementptr inbounds i32, i32* %64, i64 %560
%562 = load i32, i32* %561
%563 = getelementptr inbounds i32, i32* %66, i64 %557
%564 = load i32, i32* %563
%565 = add nsw i32 %564, %562
%566 = add nsw i64 %482, %557
%567 = getelementptr inbounds i32, i32* %64, i64 %566
store i32 %565, i32* %567
%568 = or i64 %557, 1
br label %569
569: ; preds = %559, %556
%570 = phi i64 [ %557, %556 ], [ %568, %559 ]
%571 = icmp eq i64 %558, %213
br i1 %571, label %593, label %572
572: ; preds = %569, %572
%573 = phi i64 [ %591, %572 ], [ %570, %569 ]
%574 = add nsw i64 %481, %573
%575 = getelementptr inbounds i32, i32* %64, i64 %574
%576 = load i32, i32* %575
%577 = getelementptr inbounds i32, i32* %66, i64 %573
%578 = load i32, i32* %577
%579 = add nsw i32 %578, %576
%580 = add nsw i64 %482, %573
%581 = getelementptr inbounds i32, i32* %64, i64 %580
store i32 %579, i32* %581
%582 = add nuw nsw i64 %573, 1
%583 = add nsw i64 %481, %582
%584 = getelementptr inbounds i32, i32* %64, i64 %583
%585 = load i32, i32* %584
%586 = getelementptr inbounds i32, i32* %66, i64 %582
%587 = load i32, i32* %586
%588 = add nsw i32 %587, %585
%589 = add nsw i64 %482, %582
%590 = getelementptr inbounds i32, i32* %64, i64 %589
store i32 %588, i32* %590
%591 = add nuw nsw i64 %573, 2
%592 = icmp eq i64 %591, %195
br i1 %592, label %593, label %572
593: ; preds = %569, %572, %555, %477
%594 = add nsw i64 %478, 1
%595 = icmp slt i64 %594, %448
br i1 %595, label %477, label %596
596: ; preds = %593, %462
%597 = phi i64 [ %217, %462 ], [ %594, %593 ]
%598 = add nsw i64 %597, -1
%599 = icmp sgt i64 %597, 0
br i1 %599, label %214, label %600
600: ; preds = %596, %177
%601 = phi i64 [ %179, %177 ], [ %444, %596 ]
%602 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i64 %601)
%603 = tail call i32 @free(i32* %64)
%604 = tail call i32 @free(i32* %66)
br label %605
605: ; preds = %600, %458, %450, %175, %4
ret i32 0
}