#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 /*<<< orphan*/ printf(char *);
scalar_t__ validate_position(char **, int, int);
void target_destiny_blue(char matriz[23][30], int lpack, int cpack, int lred,
                         int cred) {
  int d1, d2, lblue, cblue, aux1;
  d1 = lpack - lred;
  d2 = cpack - cred;
  if (d1 >= 0 && d2 >= 0) {
    lblue = lpack + d1;
    cblue = cpack + d2;
    if (lblue <= 21 && cblue <= 28 && validate_position(matriz, lblue, cblue)) {
      matriz[lblue][cblue] = 'D';
    } else if (lblue <= 21 && cblue <= 28 &&
               (!validate_position(matriz, lblue, cblue))) {
      while (matriz[lblue][cblue] != ' ') {
        lblue--;
      }
      matriz[lblue][cblue] = 'D';
    }
    if (lblue <= 21 && cblue > 28) {
      aux1 = cblue - 28;
      lblue = lblue + aux1;
      if (lblue <= 21 && validate_position(matriz, lblue, 28)) {
        matriz[lblue][28] = 'D';
      }
      if (lblue <= 21 && (!validate_position(matriz, lblue, 28))) {
        int n_cblue = 28;
        while (matriz[lblue][n_cblue] != ' ') {
          n_cblue--;
        }
        matriz[lblue][n_cblue] = 'D';
      }
    }
    if (lblue > 21 && cblue <= 28) {
      aux1 = lblue - 21;
      cblue = cblue + aux1;
      if (cblue <= 28 && validate_position(matriz, 21, cblue)) {
        matriz[21][cblue] = 'D';
      }
      if (cblue <= 28 && (!validate_position(matriz, 21, cblue))) {
        int n_lblue = 21;
        while (matriz[n_lblue][cblue] != ' ') {
          n_lblue--;
        }
        matriz[n_lblue][cblue] = 'D';
      }
    }
  }
  if (d1 < 0 && d2 < 0) {
    lblue = lpack + d1;
    cblue = cpack + d2;
    if (lblue > 0 && cblue > 0 && validate_position(matriz, lblue, cblue)) {
      matriz[lblue][cblue] = 'D';
    }
    if (lblue > 0 && cblue > 0 && (!validate_position(matriz, lblue, cblue))) {
      while (matriz[lblue][cblue] != ' ') {
        cblue++;
      }
      matriz[lblue][cblue] = 'D';
    }
    if (cblue <= 0) {
      lblue = lblue + cblue;
      if (lblue > 0 && validate_position(matriz, lblue, 1)) {
        matriz[lblue][1] = 'D';
      } else if (lblue > 0 && (!validate_position(matriz, lblue, 1))) {
        while (matriz[lblue][cblue] != ' ') {
          lblue++;
        }
        matriz[lblue][cblue] = 'D';
      } else {
        while (cblue < 1) {
          cblue++;
        }
        matriz[lblue][cblue] = 'D';
      }
    }
    if (lblue <= 0) {
      cblue = cblue + lblue;
      if (cblue > 0 && validate_position(matriz, 1, cblue)) {
        matriz[1][cblue] = 'D';
      }
      if (cblue > 0 && (!validate_position(matriz, 1, cblue))) {
        while (matriz[lblue][cblue] != ' ') {
          cblue++;
        }
        matriz[1][cblue] = 'D';
      } else {
        while (lblue < 1) {
          lblue--;
        }
        matriz[lblue][cblue] = 'D';
      }
    }
  }
  if (d1 > 0 && d2 < 0) {
    lblue = lpack + d1;
    cblue = cpack + d2;
    if (lblue < 21 && cblue > 0 && validate_position(matriz, lblue, cblue)) {
      matriz[lblue][cblue] = 'D';
    }
    if (lblue < 21 && cblue > 0 && (!validate_position(matriz, lblue, cblue))) {
      while (matriz[lblue][cblue] != ' ') {
        cblue++;
      }
      matriz[lblue][cblue] = 'D';
    }
    if (cblue <= 0) {
      lblue = lblue + cblue;
      if (lblue > 0 && validate_position(matriz, lblue, 1)) {
        matriz[lblue][1] = 'D';
      } else {
        if (lblue > 0 && (!validate_position(matriz, lblue, 1))) {
          while (matriz[lblue][cblue] != ' ') {
            lblue++;
          }
          matriz[lblue][cblue] = 'D';
        } else {
          while (cblue < 1) {
            cblue++;
          }
          matriz[lblue][cblue] = 'D';
        }
      }
    }
    if (lblue <= 0) {
      cblue = cblue + lblue;
      if (cblue > 0 && validate_position(matriz, 1, cblue)) {
        matriz[1][cblue] = 'D';
      }
      if (cblue > 0 && (!validate_position(matriz, 1, cblue))) {
        while (matriz[lblue][cblue] != ' ') {
          cblue++;
        }
        matriz[1][cblue] = 'D';
      } else {
        while (lblue < 1) {
          lblue--;
        }
        matriz[lblue][cblue] = 'D';
      }
    }
  }
  if (d1 < 0 && d2 > 0) {
    lblue = lpack + d1;
    cblue = cpack + d2;
    if (lblue > 0 && cblue < 28 && validate_position(matriz, lblue, cblue)) {
      matriz[lblue][cblue] = 'D';
    }
    if (lblue > 0 && cblue <= 28 &&
        (!validate_position(matriz, lblue, cblue))) {
      while (matriz[lblue][cblue] != ' ') {
        lblue--;
      }
      matriz[lblue][cblue] = 'D';
    }
    if (cblue <= 0) {
      lblue = lblue + cblue;
      if (lblue > 0 && validate_position(matriz, lblue, 1)) {
        matriz[lblue][1] = 'D';
      } else {
        if (lblue > 0 && (!validate_position(matriz, lblue, 1))) {
          while (matriz[lblue][cblue] != ' ') {
            lblue++;
          }
          matriz[lblue][cblue] = 'D';
        } else {
          while (cblue < 1) {
            cblue++;
          }
          matriz[lblue][cblue] = 'D';
        }
      }
    }
    if (lblue <= 0) {
      cblue = cblue + lblue;
      if (cblue > 0 && validate_position(matriz, 1, cblue)) {
        matriz[1][cblue] = 'D';
      }
      if (cblue > 0 && (!validate_position(matriz, 1, cblue))) {
        while (matriz[lblue][cblue] != ' ') {
          cblue++;
        }
        matriz[1][cblue] = 'D';
      } else {
        while (lblue < 1) {
          lblue--;
        }
        matriz[lblue][cblue] = 'D';
      }
    }
  }
  printf("\n\n");
}


x86 assembly (clang, -O0):
<target_destiny_blue>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     13e0 <target_destiny_blue+0x2c0>
cmpl   $0x0,-0x20(%rbp)
jl     13e0 <target_destiny_blue+0x2c0>
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x15,-0x24(%rbp)
jg     11ba <target_destiny_blue+0x9a>
cmpl   $0x1c,-0x28(%rbp)
jg     11ba <target_destiny_blue+0x9a>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     11ba <target_destiny_blue+0x9a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1236 <target_destiny_blue+0x116>
cmpl   $0x15,-0x24(%rbp)
jg     1231 <target_destiny_blue+0x111>
cmpl   $0x1c,-0x28(%rbp)
jg     1231 <target_destiny_blue+0x111>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1231 <target_destiny_blue+0x111>
jmp    11ec <target_destiny_blue+0xcc>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     121a <target_destiny_blue+0xfa>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11ec <target_destiny_blue+0xcc>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1236 <target_destiny_blue+0x116>
cmpl   $0x15,-0x24(%rbp)
jg     130a <target_destiny_blue+0x1ea>
cmpl   $0x1c,-0x28(%rbp)
jle    130a <target_destiny_blue+0x1ea>
mov    -0x28(%rbp),%eax
sub    $0x1c,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x15,-0x24(%rbp)
jg     1294 <target_destiny_blue+0x174>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1c,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1294 <target_destiny_blue+0x174>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movb   $0x44,0x1c(%rax)
cmpl   $0x15,-0x24(%rbp)
jg     1305 <target_destiny_blue+0x1e5>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1c,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1305 <target_destiny_blue+0x1e5>
movl   $0x1c,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     12ee <target_destiny_blue+0x1ce>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    12c0 <target_destiny_blue+0x1a0>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    130a <target_destiny_blue+0x1ea>
cmpl   $0x15,-0x24(%rbp)
jle    13db <target_destiny_blue+0x2bb>
cmpl   $0x1c,-0x28(%rbp)
jg     13db <target_destiny_blue+0x2bb>
mov    -0x24(%rbp),%eax
sub    $0x15,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1c,-0x28(%rbp)
jg     1365 <target_destiny_blue+0x245>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x15,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1365 <target_destiny_blue+0x245>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x276(%rax,%rcx,1)
44
cmpl   $0x1c,-0x28(%rbp)
jg     13d6 <target_destiny_blue+0x2b6>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x15,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    13d6 <target_destiny_blue+0x2b6>
movl   $0x15,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     13bf <target_destiny_blue+0x29f>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1391 <target_destiny_blue+0x271>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    13db <target_destiny_blue+0x2bb>
jmp    13e0 <target_destiny_blue+0x2c0>
cmpl   $0x0,-0x1c(%rbp)
jge    16b0 <target_destiny_blue+0x590>
cmpl   $0x0,-0x20(%rbp)
jge    16b0 <target_destiny_blue+0x590>
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    144a <target_destiny_blue+0x32a>
cmpl   $0x0,-0x28(%rbp)
jle    144a <target_destiny_blue+0x32a>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     144a <target_destiny_blue+0x32a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x0,-0x24(%rbp)
jle    14c1 <target_destiny_blue+0x3a1>
cmpl   $0x0,-0x28(%rbp)
jle    14c1 <target_destiny_blue+0x3a1>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    14c1 <target_destiny_blue+0x3a1>
jmp    147c <target_destiny_blue+0x35c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     14aa <target_destiny_blue+0x38a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    147c <target_destiny_blue+0x35c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jg     15c3 <target_destiny_blue+0x4a3>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1511 <target_destiny_blue+0x3f1>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1511 <target_destiny_blue+0x3f1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movb   $0x44,0x1(%rax)
jmp    15be <target_destiny_blue+0x49e>
cmpl   $0x0,-0x24(%rbp)
jle    1585 <target_destiny_blue+0x465>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1585 <target_destiny_blue+0x465>
jmp    153b <target_destiny_blue+0x41b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1569 <target_destiny_blue+0x449>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    153b <target_destiny_blue+0x41b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    15b9 <target_destiny_blue+0x499>
jmp    158a <target_destiny_blue+0x46a>
cmpl   $0x1,-0x28(%rbp)
jge    15a2 <target_destiny_blue+0x482>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    158a <target_destiny_blue+0x46a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    15be <target_destiny_blue+0x49e>
jmp    15c3 <target_destiny_blue+0x4a3>
cmpl   $0x0,-0x24(%rbp)
jg     16ab <target_destiny_blue+0x58b>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1608 <target_destiny_blue+0x4e8>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1608 <target_destiny_blue+0x4e8>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jle    1672 <target_destiny_blue+0x552>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1672 <target_destiny_blue+0x552>
jmp    1632 <target_destiny_blue+0x512>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1660 <target_destiny_blue+0x540>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1632 <target_destiny_blue+0x512>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
jmp    16a6 <target_destiny_blue+0x586>
jmp    1677 <target_destiny_blue+0x557>
cmpl   $0x1,-0x24(%rbp)
jge    168f <target_destiny_blue+0x56f>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1677 <target_destiny_blue+0x557>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    16ab <target_destiny_blue+0x58b>
jmp    16b0 <target_destiny_blue+0x590>
cmpl   $0x0,-0x1c(%rbp)
jle    1980 <target_destiny_blue+0x860>
cmpl   $0x0,-0x20(%rbp)
jge    1980 <target_destiny_blue+0x860>
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x15,-0x24(%rbp)
jge    171a <target_destiny_blue+0x5fa>
cmpl   $0x0,-0x28(%rbp)
jle    171a <target_destiny_blue+0x5fa>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     171a <target_destiny_blue+0x5fa>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x15,-0x24(%rbp)
jge    1791 <target_destiny_blue+0x671>
cmpl   $0x0,-0x28(%rbp)
jle    1791 <target_destiny_blue+0x671>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1791 <target_destiny_blue+0x671>
jmp    174c <target_destiny_blue+0x62c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     177a <target_destiny_blue+0x65a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    174c <target_destiny_blue+0x62c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jg     1893 <target_destiny_blue+0x773>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    17e1 <target_destiny_blue+0x6c1>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     17e1 <target_destiny_blue+0x6c1>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movb   $0x44,0x1(%rax)
jmp    188e <target_destiny_blue+0x76e>
cmpl   $0x0,-0x24(%rbp)
jle    1855 <target_destiny_blue+0x735>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1855 <target_destiny_blue+0x735>
jmp    180b <target_destiny_blue+0x6eb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1839 <target_destiny_blue+0x719>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    180b <target_destiny_blue+0x6eb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1889 <target_destiny_blue+0x769>
jmp    185a <target_destiny_blue+0x73a>
cmpl   $0x1,-0x28(%rbp)
jge    1872 <target_destiny_blue+0x752>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    185a <target_destiny_blue+0x73a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    188e <target_destiny_blue+0x76e>
jmp    1893 <target_destiny_blue+0x773>
cmpl   $0x0,-0x24(%rbp)
jg     197b <target_destiny_blue+0x85b>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    18d8 <target_destiny_blue+0x7b8>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     18d8 <target_destiny_blue+0x7b8>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jle    1942 <target_destiny_blue+0x822>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1942 <target_destiny_blue+0x822>
jmp    1902 <target_destiny_blue+0x7e2>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1930 <target_destiny_blue+0x810>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1902 <target_destiny_blue+0x7e2>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
jmp    1976 <target_destiny_blue+0x856>
jmp    1947 <target_destiny_blue+0x827>
cmpl   $0x1,-0x24(%rbp)
jge    195f <target_destiny_blue+0x83f>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1947 <target_destiny_blue+0x827>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    197b <target_destiny_blue+0x85b>
jmp    1980 <target_destiny_blue+0x860>
cmpl   $0x0,-0x1c(%rbp)
jge    1c50 <target_destiny_blue+0xb30>
cmpl   $0x0,-0x20(%rbp)
jle    1c50 <target_destiny_blue+0xb30>
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    19ea <target_destiny_blue+0x8ca>
cmpl   $0x1c,-0x28(%rbp)
jge    19ea <target_destiny_blue+0x8ca>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     19ea <target_destiny_blue+0x8ca>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x0,-0x24(%rbp)
jle    1a61 <target_destiny_blue+0x941>
cmpl   $0x1c,-0x28(%rbp)
jg     1a61 <target_destiny_blue+0x941>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x28(%rbp),%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1a61 <target_destiny_blue+0x941>
jmp    1a1c <target_destiny_blue+0x8fc>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1a4a <target_destiny_blue+0x92a>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1a1c <target_destiny_blue+0x8fc>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jg     1b63 <target_destiny_blue+0xa43>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1ab1 <target_destiny_blue+0x991>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1ab1 <target_destiny_blue+0x991>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movb   $0x44,0x1(%rax)
jmp    1b5e <target_destiny_blue+0xa3e>
cmpl   $0x0,-0x24(%rbp)
jle    1b25 <target_destiny_blue+0xa05>
mov    -0x8(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1b25 <target_destiny_blue+0xa05>
jmp    1adb <target_destiny_blue+0x9bb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1b09 <target_destiny_blue+0x9e9>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1adb <target_destiny_blue+0x9bb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1b59 <target_destiny_blue+0xa39>
jmp    1b2a <target_destiny_blue+0xa0a>
cmpl   $0x1,-0x28(%rbp)
jge    1b42 <target_destiny_blue+0xa22>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1b2a <target_destiny_blue+0xa0a>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1b5e <target_destiny_blue+0xa3e>
jmp    1b63 <target_destiny_blue+0xa43>
cmpl   $0x0,-0x24(%rbp)
jg     1c4b <target_destiny_blue+0xb2b>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1ba8 <target_destiny_blue+0xa88>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
je     1ba8 <target_destiny_blue+0xa88>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
cmpl   $0x0,-0x28(%rbp)
jle    1c12 <target_destiny_blue+0xaf2>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    $0x1,%esi
call   1040 <validate_position@plt>
cmp    $0x0,%rax
jne    1c12 <target_destiny_blue+0xaf2>
jmp    1bd2 <target_destiny_blue+0xab2>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1c00 <target_destiny_blue+0xae0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1bd2 <target_destiny_blue+0xab2>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,0x1e(%rax,%rcx,1)
jmp    1c46 <target_destiny_blue+0xb26>
jmp    1c17 <target_destiny_blue+0xaf7>
cmpl   $0x1,-0x24(%rbp)
jge    1c2f <target_destiny_blue+0xb0f>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1c17 <target_destiny_blue+0xaf7>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x1e,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movb   $0x44,(%rax,%rcx,1)
jmp    1c4b <target_destiny_blue+0xb2b>
jmp    1c50 <target_destiny_blue+0xb30>
lea    0x3a9(%rip),%rdi
call   1030 <printf@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<target_destiny_blue>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%r13
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
mov    %r8d,0x24(%rsp)
sub    %r8d,%edx
mov    %esi,%ebp
mov    %ecx,0x14(%rsp)
sub    %ecx,%ebp
mov    %rsi,0x8(%rsp)
js     12fd <target_destiny_blue+0x1dd>
test   %edx,%edx
js     12fd <target_destiny_blue+0x1dd>
lea    (%rsi,%rbp,1),%ebx
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,1),%r15d
cmp    $0x15,%ebx
jg     1200 <target_destiny_blue+0xe0>
cmp    $0x1c,%r15d
jg     1200 <target_destiny_blue+0xe0>
mov    %rdx,%r14
mov    %r13,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     11ae <target_destiny_blue+0x8e>
movslq %ebx,%rax
movslq %r15d,%rcx
mov    %rax,%rdx
shl    $0x5,%rdx
sub    %rax,%rdx
sub    %rax,%rdx
add    %rdx,%r13
add    %rcx,%r13
jmp    17fc <target_destiny_blue+0x6dc>
mov    %r13,%rdi
mov    %ebx,%esi
mov    %r15d,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    0x8(%rsp),%rsi
jne    1801 <target_destiny_blue+0x6e1>
mov    %r14,%rdx
movslq %r15d,%rcx
movslq %ebx,%rdi
lea    (%rsi,%rsi,1),%ebx
sub    0x14(%rsp),%ebx
add    $0x1,%ebx
mov    %rdi,%rax
shl    $0x5,%rax
sub    %rdi,%rax
sub    %rdi,%rax
add    %r13,%rax
add    %rcx,%rax
nop
add    $0xffffffff,%ebx
cmpb   $0x20,(%rax)
lea    -0x1e(%rax),%rax
jne    11f0 <target_destiny_blue+0xd0>
movb   $0x44,0x1e(%rax)
cmp    $0x15,%ebx
jg     128d <target_destiny_blue+0x16d>
cmp    $0x1d,%r15d
jl     128d <target_destiny_blue+0x16d>
add    %r15d,%ebx
add    $0xffffffe4,%ebx
cmp    $0x15,%ebx
jg     128d <target_destiny_blue+0x16d>
mov    %rdx,%r12
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1c,%edx
call   1040 <validate_position@plt>
movslq %ebx,%r14
test   %rax,%rax
je     124b <target_destiny_blue+0x12b>
mov    %r14,%rax
shl    $0x5,%rax
sub    %r14,%rax
sub    %r14,%rax
movb   $0x44,0x1c(%r13,%rax,1)
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1c,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    %r12,%rdx
mov    0x8(%rsp),%rsi
jne    12fd <target_destiny_blue+0x1dd>
mov    %r14,%rax
shl    $0x5,%rax
sub    %r14,%rax
sub    %r14,%rax
add    %r13,%rax
add    $0x1d,%rax
nop
cmpb   $0x20,-0x1(%rax)
lea    -0x1(%rax),%rax
jne    1280 <target_destiny_blue+0x160>
movb   $0x44,(%rax)
cmp    $0x16,%ebx
jl     12fd <target_destiny_blue+0x1dd>
cmp    $0x1c,%r15d
jg     12fd <target_destiny_blue+0x1dd>
add    %r15d,%ebx
add    $0xffffffeb,%ebx
cmp    $0x1c,%ebx
jg     12fd <target_destiny_blue+0x1dd>
mov    %rdx,%r15
mov    %r13,%rdi
mov    $0x15,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
movslq %ebx,%r14
test   %rax,%rax
je     12c6 <target_destiny_blue+0x1a6>
movb   $0x44,0x276(%r13,%r14,1)
mov    %r13,%rdi
mov    $0x15,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    %r15,%rdx
mov    0x8(%rsp),%rsi
jne    12fd <target_destiny_blue+0x1dd>
lea    (%r14,%r13,1),%rax
add    $0x294,%rax
nopl   0x0(%rax)
cmpb   $0x20,-0x1e(%rax)
lea    -0x1e(%rax),%rax
jne    12f0 <target_destiny_blue+0x1d0>
movb   $0x44,(%rax)
mov    %ebp,%r14d
shr    $0x1f,%r14d
mov    %edx,%eax
shr    $0x1f,%eax
test   %ebp,%ebp
jns    14cb <target_destiny_blue+0x3ab>
test   %edx,%edx
jns    14cb <target_destiny_blue+0x3ab>
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,1),%r12d
mov    %ebp,%r15d
add    %esi,%r15d
jle    13c1 <target_destiny_blue+0x2a1>
test   %r12d,%r12d
jle    13c1 <target_destiny_blue+0x2a1>
mov    %rdx,%rbx
mov    %r13,%rdi
mov    %r15d,%esi
mov    %r12d,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     1367 <target_destiny_blue+0x247>
mov    %r15d,%eax
mov    %r12d,%ecx
mov    %rax,%rdx
shl    $0x5,%rdx
sub    %rax,%rdx
sub    %rax,%rdx
add    %r13,%rdx
movb   $0x44,(%rcx,%rdx,1)
mov    %r13,%rdi
mov    %r15d,%esi
mov    %r12d,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    0x8(%rsp),%rsi
jne    1801 <target_destiny_blue+0x6e1>
mov    %rbx,%rdx
mov    %r15d,%ecx
mov    %r12d,%ebx
mov    0x24(%rsp),%eax
not    %eax
mov    0x18(%rsp),%rdi
lea    (%rax,%rdi,2),%r12d
mov    %rcx,%rax
shl    $0x5,%rax
sub    %rcx,%rax
sub    %rcx,%rax
add    %r13,%rax
add    %rbx,%rax
xchg   %ax,%ax
add    $0x1,%r12d
cmpb   $0x20,(%rax)
lea    0x1(%rax),%rax
jne    13b0 <target_destiny_blue+0x290>
movb   $0x44,-0x1(%rax)
test   %r12d,%r12d
jg     144c <target_destiny_blue+0x32c>
add    %r12d,%r15d
test   %r15d,%r15d
jle    142b <target_destiny_blue+0x30b>
mov    %rdx,%rbx
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     140a <target_destiny_blue+0x2ea>
mov    %r15d,%eax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
lea    (%rcx,%r13,1),%rax
add    $0x1,%rax
mov    %rbx,%rdx
jmp    14be <target_destiny_blue+0x39e>
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    %rbx,%rdx
mov    0x8(%rsp),%rsi
je     18b2 <target_destiny_blue+0x792>
movslq %r15d,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
lea    (%rcx,%r13,1),%rax
add    $0x1,%rax
mov    $0x1,%r12d
movb   $0x44,(%rax)
mov    $0x1,%al
mov    $0x1,%r14b
test   %r15d,%r15d
jg     14cb <target_destiny_blue+0x3ab>
mov    %rdx,%r14
add    %r15d,%r12d
mov    %r13,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1040 <validate_position@plt>
mov    %r12d,%ebx
test   %rax,%rax
je     147a <target_destiny_blue+0x35a>
movb   $0x44,0x1e(%r13,%rbx,1)
mov    %r13,%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   1040 <validate_position@plt>
movslq %r15d,%rdx
lea    (%rbx,%r13,1),%rax
add    $0x1d,%rax
mov    %rdx,%rcx
shl    $0x5,%rcx
sub    %rdx,%rcx
sub    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x20,-0x1d(%rax,%rcx,1)
lea    0x1(%rax),%rax
jne    14b0 <target_destiny_blue+0x390>
mov    %r14,%rdx
mov    0x8(%rsp),%rsi
movb   $0x44,(%rax)
mov    $0x1,%al
mov    $0x1,%r14b
test   %ebp,%ebp
jle    165d <target_destiny_blue+0x53d>
test   %al,%al
je     165d <target_destiny_blue+0x53d>
lea    (%rsi,%rbp,1),%r15d
mov    0x18(%rsp),%rax
lea    (%rdx,%rax,1),%ebx
cmp    $0x14,%r15d
jg     15a0 <target_destiny_blue+0x480>
test   %ebx,%ebx
jle    15a0 <target_destiny_blue+0x480>
mov    %rdx,0x28(%rsp)
mov    %r13,%rdi
mov    %r15d,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
movslq %r15d,%r12
mov    %ebx,%ecx
test   %rax,%rax
je     1529 <target_destiny_blue+0x409>
mov    %r12,%rax
shl    $0x5,%rax
sub    %r12,%rax
sub    %r12,%rax
add    %r13,%rax
movb   $0x44,(%rcx,%rax,1)
mov    %rcx,0x30(%rsp)
mov    %r13,%rdi
mov    %r15d,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     1555 <target_destiny_blue+0x435>
mov    0x28(%rsp),%rdx
mov    0x8(%rsp),%rsi
test   %r15d,%r15d
jg     165d <target_destiny_blue+0x53d>
jmp    15ad <target_destiny_blue+0x48d>
mov    0x24(%rsp),%eax
not    %eax
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,2),%ebx
mov    %r12,%rax
shl    $0x5,%rax
sub    %r12,%rax
sub    %r12,%rax
add    %r13,%rax
add    0x30(%rsp),%rax
mov    0x28(%rsp),%rdx
mov    0x8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%ebx
cmpb   $0x20,(%rax)
lea    0x1(%rax),%rax
jne    1590 <target_destiny_blue+0x470>
movb   $0x44,-0x1(%rax)
test   %ebx,%ebx
jle    1612 <target_destiny_blue+0x4f2>
test   %r15d,%r15d
jg     165d <target_destiny_blue+0x53d>
mov    %rdx,0x28(%rsp)
add    %r15d,%ebx
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
mov    %ebx,%r12d
test   %rax,%rax
je     15d2 <target_destiny_blue+0x4b2>
movb   $0x44,0x1e(%r13,%r12,1)
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1040 <validate_position@plt>
movslq %r15d,%rdx
lea    (%r12,%r13,1),%rax
add    $0x1d,%rax
mov    %rdx,%rcx
shl    $0x5,%rcx
sub    %rdx,%rcx
sub    %rdx,%rcx
nopl   0x0(%rax)
cmpb   $0x20,-0x1d(%rax,%rcx,1)
lea    0x1(%rax),%rax
jne    1600 <target_destiny_blue+0x4e0>
mov    0x28(%rsp),%rdx
jmp    1655 <target_destiny_blue+0x535>
add    %ebx,%r15d
test   %r15d,%r15d
jle    183c <target_destiny_blue+0x71c>
mov    %rdx,%r12
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     181b <target_destiny_blue+0x6fb>
mov    %r15d,%eax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
lea    (%rcx,%r13,1),%rax
add    $0x1,%rax
mov    %r12,%rdx
mov    0x8(%rsp),%rsi
movb   $0x44,(%rax)
test   %edx,%edx
setg   %al
and    %al,%r14b
cmp    $0x1,%r14b
jne    1801 <target_destiny_blue+0x6e1>
add    %esi,%ebp
add    0x18(%rsp),%edx
test   %ebp,%ebp
jle    16ac <target_destiny_blue+0x58c>
cmp    $0x1b,%edx
jg     16ac <target_destiny_blue+0x58c>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %rdx,%rbx
call   1040 <validate_position@plt>
mov    %rbx,%rdx
test   %rax,%rax
je     16ac <target_destiny_blue+0x58c>
mov    %ebp,%eax
movslq %edx,%rcx
mov    %rax,%rsi
shl    $0x5,%rsi
sub    %rax,%rsi
sub    %rax,%rsi
add    %r13,%rsi
movb   $0x44,(%rcx,%rsi,1)
test   %ebp,%ebp
jle    16ca <target_destiny_blue+0x5aa>
cmp    $0x1c,%edx
jg     16ca <target_destiny_blue+0x5aa>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %rdx,%rbx
call   1040 <validate_position@plt>
test   %rax,%rax
je     16db <target_destiny_blue+0x5bb>
mov    %rbx,%rdx
test   %edx,%edx
jle    1724 <target_destiny_blue+0x604>
test   %ebp,%ebp
jg     1801 <target_destiny_blue+0x6e1>
jmp    179b <target_destiny_blue+0x67b>
movslq %ebx,%rcx
mov    %ebp,%edx
mov    0x8(%rsp),%rbp
add    %ebp,%ebp
sub    0x14(%rsp),%ebp
add    $0x1,%ebp
mov    %rdx,%rax
shl    $0x5,%rax
sub    %rdx,%rax
sub    %rdx,%rax
add    %r13,%rax
add    %rcx,%rax
mov    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffff,%ebp
cmpb   $0x20,(%rax)
lea    -0x1e(%rax),%rax
jne    1710 <target_destiny_blue+0x5f0>
movb   $0x44,0x1e(%rax)
test   %edx,%edx
jg     16ce <target_destiny_blue+0x5ae>
lea    (%rdx,%rbp,1),%ebx
test   %ebx,%ebx
jle    1775 <target_destiny_blue+0x655>
mov    %rdx,%r14
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     175d <target_destiny_blue+0x63d>
mov    %ebx,%eax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
add    %rcx,%r13
add    $0x1,%r13
jmp    17fc <target_destiny_blue+0x6dc>
mov    %r13,%rdi
mov    %ebx,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
je     186a <target_destiny_blue+0x74a>
movslq %ebx,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
lea    (%rcx,%r13,1),%rax
add    $0x1,%rax
mov    $0x1,%edx
movb   $0x44,(%rax)
mov    %ebx,%ebp
test   %ebp,%ebp
jg     1801 <target_destiny_blue+0x6e1>
add    %ebp,%edx
mov    %r13,%rdi
mov    $0x1,%esi
mov    %rdx,%rbx
call   1040 <validate_position@plt>
mov    %rbx,%rdx
mov    %edx,%ebx
test   %rax,%rax
je     17bd <target_destiny_blue+0x69d>
movb   $0x44,0x1e(%r13,%rbx,1)
mov    %r13,%rdi
mov    $0x1,%esi
call   1040 <validate_position@plt>
movslq %ebp,%rcx
add    %rbx,%r13
add    $0x1d,%r13
mov    %rcx,%rax
shl    $0x5,%rax
sub    %rcx,%rax
sub    %rcx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x20,-0x1d(%r13,%rax,1)
lea    0x1(%r13),%r13
jne    17f0 <target_destiny_blue+0x6d0>
movb   $0x44,0x0(%r13)
lea    0x7f8(%rip),%rdi
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
call   1040 <validate_position@plt>
test   %rax,%rax
mov    %r12,%rdx
mov    0x8(%rsp),%rsi
je     18f3 <target_destiny_blue+0x7d3>
movslq %r15d,%rax
mov    %rax,%rcx
shl    $0x5,%rcx
sub    %rax,%rcx
sub    %rax,%rcx
lea    (%rcx,%r13,1),%rax
add    $0x1,%rax
mov    $0x1,%ebx
movb   $0x44,(%rax)
test   %r15d,%r15d
jg     165d <target_destiny_blue+0x53d>
jmp    15ad <target_destiny_blue+0x48d>
mov    %r14,%rdx
movslq %edx,%rax
mov    %ebx,%ecx
mov    0x18(%rsp),%rsi
lea    0x0(%rbp,%rsi,2),%esi
mov    0x24(%rsp),%ebx
not    %ebx
add    %esi,%ebx
mov    %rcx,%rsi
shl    $0x5,%rsi
sub    %rcx,%rsi
sub    %rcx,%rsi
add    %r13,%rsi
add    %rsi,%rax
add    $0xffffffffffffffe2,%rax
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebx
cmpb   $0x20,0x1e(%rax)
lea    0x1e(%rax),%rax
jne    18a0 <target_destiny_blue+0x780>
jmp    1792 <target_destiny_blue+0x672>
movslq %r12d,%rax
mov    %r15d,%ecx
lea    (%r12,%rsi,2),%edi
mov    0x14(%rsp),%r15d
not    %r15d
add    %edi,%r15d
mov    %rcx,%rdi
shl    $0x5,%rdi
sub    %rcx,%rdi
sub    %rcx,%rdi
add    %r13,%rdi
add    %rdi,%rax
add    $0xffffffffffffffe2,%rax
xchg   %ax,%ax
add    $0x1,%r15d
cmpb   $0x20,0x1e(%rax)
lea    0x1e(%rax),%rax
jne    18e0 <target_destiny_blue+0x7c0>
jmp    1449 <target_destiny_blue+0x329>
movslq %ebx,%rax
mov    %r15d,%ecx
lea    (%rbx,%rsi,2),%edi
mov    0x14(%rsp),%r15d
not    %r15d
add    %edi,%r15d
mov    %rcx,%rdi
shl    $0x5,%rdi
sub    %rcx,%rdi
sub    %rcx,%rdi
add    %r13,%rdi
add    %rdi,%rax
add    $0xffffffffffffffe2,%rax
xchg   %ax,%ax
add    $0x1,%r15d
cmpb   $0x20,0x1e(%rax)
lea    0x1e(%rax),%rax
jne    1920 <target_destiny_blue+0x800>
jmp    1859 <target_destiny_blue+0x739>

LLVM IR (-O0):
@.str = [3 x i8] c"\0A\0A\00"
define void @target_destiny_blue([30 x i8]* %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca [30 x i8]*
%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
store [30 x i8]* %0, [30 x i8]** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%18 = load i32, i32* %7
%19 = load i32, i32* %9
%20 = sub nsw i32 %18, %19
store i32 %20, i32* %11
%21 = load i32, i32* %8
%22 = load i32, i32* %10
%23 = sub nsw i32 %21, %22
store i32 %23, i32* %12
%24 = load i32, i32* %11
%25 = icmp sge i32 %24, 0
br i1 %25, label %26, label %212
26: ; preds = %5
%27 = load i32, i32* %12
%28 = icmp sge i32 %27, 0
br i1 %28, label %29, label %212
29: ; preds = %26
%30 = load i32, i32* %7
%31 = load i32, i32* %11
%32 = add nsw i32 %30, %31
store i32 %32, i32* %13
%33 = load i32, i32* %8
%34 = load i32, i32* %12
%35 = add nsw i32 %33, %34
store i32 %35, i32* %14
%36 = load i32, i32* %13
%37 = icmp sle i32 %36, 21
br i1 %37, label %38, label %56
38: ; preds = %29
%39 = load i32, i32* %14
%40 = icmp sle i32 %39, 28
br i1 %40, label %41, label %56
41: ; preds = %38
%42 = load [30 x i8]*, [30 x i8]** %6
%43 = bitcast [30 x i8]* %42 to i8**
%44 = load i32, i32* %13
%45 = load i32, i32* %14
%46 = call i64 @validate_position(i8** %43, i32 %44, i32 %45)
%47 = icmp ne i64 %46, 0
br i1 %47, label %48, label %56
48: ; preds = %41
%49 = load [30 x i8]*, [30 x i8]** %6
%50 = load i32, i32* %13
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [30 x i8], [30 x i8]* %49, i64 %51
%53 = load i32, i32* %14
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [30 x i8], [30 x i8]* %52, i64 0, i64 %54
store i8 68, i8* %55
br label %93
56: ; preds = %41, %38, %29
%57 = load i32, i32* %13
%58 = icmp sle i32 %57, 21
br i1 %58, label %59, label %92
59: ; preds = %56
%60 = load i32, i32* %14
%61 = icmp sle i32 %60, 28
br i1 %61, label %62, label %92
62: ; preds = %59
%63 = load [30 x i8]*, [30 x i8]** %6
%64 = bitcast [30 x i8]* %63 to i8**
%65 = load i32, i32* %13
%66 = load i32, i32* %14
%67 = call i64 @validate_position(i8** %64, i32 %65, i32 %66)
%68 = icmp ne i64 %67, 0
br i1 %68, label %92, label %69
69: ; preds = %62
br label %70
70: ; preds = %81, %69
%71 = load [30 x i8]*, [30 x i8]** %6
%72 = load i32, i32* %13
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [30 x i8], [30 x i8]* %71, i64 %73
%75 = load i32, i32* %14
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [30 x i8], [30 x i8]* %74, i64 0, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = icmp ne i32 %79, 32
br i1 %80, label %81, label %84
81: ; preds = %70
%82 = load i32, i32* %13
%83 = add nsw i32 %82, -1
store i32 %83, i32* %13
br label %70
84: ; preds = %70
%85 = load [30 x i8]*, [30 x i8]** %6
%86 = load i32, i32* %13
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [30 x i8], [30 x i8]* %85, i64 %87
%89 = load i32, i32* %14
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [30 x i8], [30 x i8]* %88, i64 0, i64 %90
store i8 68, i8* %91
br label %92
92: ; preds = %84, %62, %59, %56
br label %93
93: ; preds = %92, %48
%94 = load i32, i32* %13
%95 = icmp sle i32 %94, 21
br i1 %95, label %96, label %152
96: ; preds = %93
%97 = load i32, i32* %14
%98 = icmp sgt i32 %97, 28
br i1 %98, label %99, label %152
99: ; preds = %96
%100 = load i32, i32* %14
%101 = sub nsw i32 %100, 28
store i32 %101, i32* %15
%102 = load i32, i32* %13
%103 = load i32, i32* %15
%104 = add nsw i32 %102, %103
store i32 %104, i32* %13
%105 = load i32, i32* %13
%106 = icmp sle i32 %105, 21
br i1 %106, label %107, label %119
107: ; preds = %99
%108 = load [30 x i8]*, [30 x i8]** %6
%109 = bitcast [30 x i8]* %108 to i8**
%110 = load i32, i32* %13
%111 = call i64 @validate_position(i8** %109, i32 %110, i32 28)
%112 = icmp ne i64 %111, 0
br i1 %112, label %113, label %119
113: ; preds = %107
%114 = load [30 x i8]*, [30 x i8]** %6
%115 = load i32, i32* %13
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [30 x i8], [30 x i8]* %114, i64 %116
%118 = getelementptr inbounds [30 x i8], [30 x i8]* %117, i64 0, i64 28
store i8 68, i8* %118
br label %119
119: ; preds = %113, %107, %99
%120 = load i32, i32* %13
%121 = icmp sle i32 %120, 21
br i1 %121, label %122, label %151
122: ; preds = %119
%123 = load [30 x i8]*, [30 x i8]** %6
%124 = bitcast [30 x i8]* %123 to i8**
%125 = load i32, i32* %13
%126 = call i64 @validate_position(i8** %124, i32 %125, i32 28)
%127 = icmp ne i64 %126, 0
br i1 %127, label %151, label %128
128: ; preds = %122
store i32 28, i32* %16
br label %129
129: ; preds = %140, %128
%130 = load [30 x i8]*, [30 x i8]** %6
%131 = load i32, i32* %13
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [30 x i8], [30 x i8]* %130, i64 %132
%134 = load i32, i32* %16
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [30 x i8], [30 x i8]* %133, i64 0, i64 %135
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = icmp ne i32 %138, 32
br i1 %139, label %140, label %143
140: ; preds = %129
%141 = load i32, i32* %16
%142 = add nsw i32 %141, -1
store i32 %142, i32* %16
br label %129
143: ; preds = %129
%144 = load [30 x i8]*, [30 x i8]** %6
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [30 x i8], [30 x i8]* %144, i64 %146
%148 = load i32, i32* %16
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [30 x i8], [30 x i8]* %147, i64 0, i64 %149
store i8 68, i8* %150
br label %151
151: ; preds = %143, %122, %119
br label %152
152: ; preds = %151, %96, %93
%153 = load i32, i32* %13
%154 = icmp sgt i32 %153, 21
br i1 %154, label %155, label %211
155: ; preds = %152
%156 = load i32, i32* %14
%157 = icmp sle i32 %156, 28
br i1 %157, label %158, label %211
158: ; preds = %155
%159 = load i32, i32* %13
%160 = sub nsw i32 %159, 21
store i32 %160, i32* %15
%161 = load i32, i32* %14
%162 = load i32, i32* %15
%163 = add nsw i32 %161, %162
store i32 %163, i32* %14
%164 = load i32, i32* %14
%165 = icmp sle i32 %164, 28
br i1 %165, label %166, label %178
166: ; preds = %158
%167 = load [30 x i8]*, [30 x i8]** %6
%168 = bitcast [30 x i8]* %167 to i8**
%169 = load i32, i32* %14
%170 = call i64 @validate_position(i8** %168, i32 21, i32 %169)
%171 = icmp ne i64 %170, 0
br i1 %171, label %172, label %178
172: ; preds = %166
%173 = load [30 x i8]*, [30 x i8]** %6
%174 = getelementptr inbounds [30 x i8], [30 x i8]* %173, i64 21
%175 = load i32, i32* %14
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [30 x i8], [30 x i8]* %174, i64 0, i64 %176
store i8 68, i8* %177
br label %178
178: ; preds = %172, %166, %158
%179 = load i32, i32* %14
%180 = icmp sle i32 %179, 28
br i1 %180, label %181, label %210
181: ; preds = %178
%182 = load [30 x i8]*, [30 x i8]** %6
%183 = bitcast [30 x i8]* %182 to i8**
%184 = load i32, i32* %14
%185 = call i64 @validate_position(i8** %183, i32 21, i32 %184)
%186 = icmp ne i64 %185, 0
br i1 %186, label %210, label %187
187: ; preds = %181
store i32 21, i32* %17
br label %188
188: ; preds = %199, %187
%189 = load [30 x i8]*, [30 x i8]** %6
%190 = load i32, i32* %17
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [30 x i8], [30 x i8]* %189, i64 %191
%193 = load i32, i32* %14
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [30 x i8], [30 x i8]* %192, i64 0, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = icmp ne i32 %197, 32
br i1 %198, label %199, label %202
199: ; preds = %188
%200 = load i32, i32* %17
%201 = add nsw i32 %200, -1
store i32 %201, i32* %17
br label %188
202: ; preds = %188
%203 = load [30 x i8]*, [30 x i8]** %6
%204 = load i32, i32* %17
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [30 x i8], [30 x i8]* %203, i64 %205
%207 = load i32, i32* %14
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [30 x i8], [30 x i8]* %206, i64 0, i64 %208
store i8 68, i8* %209
br label %210
210: ; preds = %202, %181, %178
br label %211
211: ; preds = %210, %155, %152
br label %212
212: ; preds = %211, %26, %5
%213 = load i32, i32* %11
%214 = icmp slt i32 %213, 0
br i1 %214, label %215, label %419
215: ; preds = %212
%216 = load i32, i32* %12
%217 = icmp slt i32 %216, 0
br i1 %217, label %218, label %419
218: ; preds = %215
%219 = load i32, i32* %7
%220 = load i32, i32* %11
%221 = add nsw i32 %219, %220
store i32 %221, i32* %13
%222 = load i32, i32* %8
%223 = load i32, i32* %12
%224 = add nsw i32 %222, %223
store i32 %224, i32* %14
%225 = load i32, i32* %13
%226 = icmp sgt i32 %225, 0
br i1 %226, label %227, label %245
227: ; preds = %218
%228 = load i32, i32* %14
%229 = icmp sgt i32 %228, 0
br i1 %229, label %230, label %245
230: ; preds = %227
%231 = load [30 x i8]*, [30 x i8]** %6
%232 = bitcast [30 x i8]* %231 to i8**
%233 = load i32, i32* %13
%234 = load i32, i32* %14
%235 = call i64 @validate_position(i8** %232, i32 %233, i32 %234)
%236 = icmp ne i64 %235, 0
br i1 %236, label %237, label %245
237: ; preds = %230
%238 = load [30 x i8]*, [30 x i8]** %6
%239 = load i32, i32* %13
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [30 x i8], [30 x i8]* %238, i64 %240
%242 = load i32, i32* %14
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [30 x i8], [30 x i8]* %241, i64 0, i64 %243
store i8 68, i8* %244
br label %245
245: ; preds = %237, %230, %227, %218
%246 = load i32, i32* %13
%247 = icmp sgt i32 %246, 0
br i1 %247, label %248, label %281
248: ; preds = %245
%249 = load i32, i32* %14
%250 = icmp sgt i32 %249, 0
br i1 %250, label %251, label %281
251: ; preds = %248
%252 = load [30 x i8]*, [30 x i8]** %6
%253 = bitcast [30 x i8]* %252 to i8**
%254 = load i32, i32* %13
%255 = load i32, i32* %14
%256 = call i64 @validate_position(i8** %253, i32 %254, i32 %255)
%257 = icmp ne i64 %256, 0
br i1 %257, label %281, label %258
258: ; preds = %251
br label %259
259: ; preds = %270, %258
%260 = load [30 x i8]*, [30 x i8]** %6
%261 = load i32, i32* %13
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [30 x i8], [30 x i8]* %260, i64 %262
%264 = load i32, i32* %14
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [30 x i8], [30 x i8]* %263, i64 0, i64 %265
%267 = load i8, i8* %266
%268 = sext i8 %267 to i32
%269 = icmp ne i32 %268, 32
br i1 %269, label %270, label %273
270: ; preds = %259
%271 = load i32, i32* %14
%272 = add nsw i32 %271, 1
store i32 %272, i32* %14
br label %259
273: ; preds = %259
%274 = load [30 x i8]*, [30 x i8]** %6
%275 = load i32, i32* %13
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [30 x i8], [30 x i8]* %274, i64 %276
%278 = load i32, i32* %14
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [30 x i8], [30 x i8]* %277, i64 0, i64 %279
store i8 68, i8* %280
br label %281
281: ; preds = %273, %251, %248, %245
%282 = load i32, i32* %14
%283 = icmp sle i32 %282, 0
br i1 %283, label %284, label %351
284: ; preds = %281
%285 = load i32, i32* %13
%286 = load i32, i32* %14
%287 = add nsw i32 %285, %286
store i32 %287, i32* %13
%288 = load i32, i32* %13
%289 = icmp sgt i32 %288, 0
br i1 %289, label %290, label %302
290: ; preds = %284
%291 = load [30 x i8]*, [30 x i8]** %6
%292 = bitcast [30 x i8]* %291 to i8**
%293 = load i32, i32* %13
%294 = call i64 @validate_position(i8** %292, i32 %293, i32 1)
%295 = icmp ne i64 %294, 0
br i1 %295, label %296, label %302
296: ; preds = %290
%297 = load [30 x i8]*, [30 x i8]** %6
%298 = load i32, i32* %13
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [30 x i8], [30 x i8]* %297, i64 %299
%301 = getelementptr inbounds [30 x i8], [30 x i8]* %300, i64 0, i64 1
store i8 68, i8* %301
br label %350
302: ; preds = %290, %284
%303 = load i32, i32* %13
%304 = icmp sgt i32 %303, 0
br i1 %304, label %305, label %334
305: ; preds = %302
%306 = load [30 x i8]*, [30 x i8]** %6
%307 = bitcast [30 x i8]* %306 to i8**
%308 = load i32, i32* %13
%309 = call i64 @validate_position(i8** %307, i32 %308, i32 1)
%310 = icmp ne i64 %309, 0
br i1 %310, label %334, label %311
311: ; preds = %305
br label %312
312: ; preds = %323, %311
%313 = load [30 x i8]*, [30 x i8]** %6
%314 = load i32, i32* %13
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [30 x i8], [30 x i8]* %313, i64 %315
%317 = load i32, i32* %14
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds [30 x i8], [30 x i8]* %316, i64 0, i64 %318
%320 = load i8, i8* %319
%321 = sext i8 %320 to i32
%322 = icmp ne i32 %321, 32
br i1 %322, label %323, label %326
323: ; preds = %312
%324 = load i32, i32* %13
%325 = add nsw i32 %324, 1
store i32 %325, i32* %13
br label %312
326: ; preds = %312
%327 = load [30 x i8]*, [30 x i8]** %6
%328 = load i32, i32* %13
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [30 x i8], [30 x i8]* %327, i64 %329
%331 = load i32, i32* %14
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [30 x i8], [30 x i8]* %330, i64 0, i64 %332
store i8 68, i8* %333
br label %349
334: ; preds = %305, %302
br label %335
335: ; preds = %338, %334
%336 = load i32, i32* %14
%337 = icmp slt i32 %336, 1
br i1 %337, label %338, label %341
338: ; preds = %335
%339 = load i32, i32* %14
%340 = add nsw i32 %339, 1
store i32 %340, i32* %14
br label %335
341: ; preds = %335
%342 = load [30 x i8]*, [30 x i8]** %6
%343 = load i32, i32* %13
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds [30 x i8], [30 x i8]* %342, i64 %344
%346 = load i32, i32* %14
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [30 x i8], [30 x i8]* %345, i64 0, i64 %347
store i8 68, i8* %348
br label %349
349: ; preds = %341, %326
br label %350
350: ; preds = %349, %296
br label %351
351: ; preds = %350, %281
%352 = load i32, i32* %13
%353 = icmp sle i32 %352, 0
br i1 %353, label %354, label %418
354: ; preds = %351
%355 = load i32, i32* %14
%356 = load i32, i32* %13
%357 = add nsw i32 %355, %356
store i32 %357, i32* %14
%358 = load i32, i32* %14
%359 = icmp sgt i32 %358, 0
br i1 %359, label %360, label %372
360: ; preds = %354
%361 = load [30 x i8]*, [30 x i8]** %6
%362 = bitcast [30 x i8]* %361 to i8**
%363 = load i32, i32* %14
%364 = call i64 @validate_position(i8** %362, i32 1, i32 %363)
%365 = icmp ne i64 %364, 0
br i1 %365, label %366, label %372
366: ; preds = %360
%367 = load [30 x i8]*, [30 x i8]** %6
%368 = getelementptr inbounds [30 x i8], [30 x i8]* %367, i64 1
%369 = load i32, i32* %14
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [30 x i8], [30 x i8]* %368, i64 0, i64 %370
store i8 68, i8* %371
br label %372
372: ; preds = %366, %360, %354
%373 = load i32, i32* %14
%374 = icmp sgt i32 %373, 0
br i1 %374, label %375, label %402
375: ; preds = %372
%376 = load [30 x i8]*, [30 x i8]** %6
%377 = bitcast [30 x i8]* %376 to i8**
%378 = load i32, i32* %14
%379 = call i64 @validate_position(i8** %377, i32 1, i32 %378)
%380 = icmp ne i64 %379, 0
br i1 %380, label %402, label %381
381: ; preds = %375
br label %382
382: ; preds = %393, %381
%383 = load [30 x i8]*, [30 x i8]** %6
%384 = load i32, i32* %13
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds [30 x i8], [30 x i8]* %383, i64 %385
%387 = load i32, i32* %14
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds [30 x i8], [30 x i8]* %386, i64 0, i64 %388
%390 = load i8, i8* %389
%391 = sext i8 %390 to i32
%392 = icmp ne i32 %391, 32
br i1 %392, label %393, label %396
393: ; preds = %382
%394 = load i32, i32* %14
%395 = add nsw i32 %394, 1
store i32 %395, i32* %14
br label %382
396: ; preds = %382
%397 = load [30 x i8]*, [30 x i8]** %6
%398 = getelementptr inbounds [30 x i8], [30 x i8]* %397, i64 1
%399 = load i32, i32* %14
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [30 x i8], [30 x i8]* %398, i64 0, i64 %400
store i8 68, i8* %401
br label %417
402: ; preds = %375, %372
br label %403
403: ; preds = %406, %402
%404 = load i32, i32* %13
%405 = icmp slt i32 %404, 1
br i1 %405, label %406, label %409
406: ; preds = %403
%407 = load i32, i32* %13
%408 = add nsw i32 %407, -1
store i32 %408, i32* %13
br label %403
409: ; preds = %403
%410 = load [30 x i8]*, [30 x i8]** %6
%411 = load i32, i32* %13
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds [30 x i8], [30 x i8]* %410, i64 %412
%414 = load i32, i32* %14
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds [30 x i8], [30 x i8]* %413, i64 0, i64 %415
store i8 68, i8* %416
br label %417
417: ; preds = %409, %396
br label %418
418: ; preds = %417, %351
br label %419
419: ; preds = %418, %215, %212
%420 = load i32, i32* %11
%421 = icmp sgt i32 %420, 0
br i1 %421, label %422, label %626
422: ; preds = %419
%423 = load i32, i32* %12
%424 = icmp slt i32 %423, 0
br i1 %424, label %425, label %626
425: ; preds = %422
%426 = load i32, i32* %7
%427 = load i32, i32* %11
%428 = add nsw i32 %426, %427
store i32 %428, i32* %13
%429 = load i32, i32* %8
%430 = load i32, i32* %12
%431 = add nsw i32 %429, %430
store i32 %431, i32* %14
%432 = load i32, i32* %13
%433 = icmp slt i32 %432, 21
br i1 %433, label %434, label %452
434: ; preds = %425
%435 = load i32, i32* %14
%436 = icmp sgt i32 %435, 0
br i1 %436, label %437, label %452
437: ; preds = %434
%438 = load [30 x i8]*, [30 x i8]** %6
%439 = bitcast [30 x i8]* %438 to i8**
%440 = load i32, i32* %13
%441 = load i32, i32* %14
%442 = call i64 @validate_position(i8** %439, i32 %440, i32 %441)
%443 = icmp ne i64 %442, 0
br i1 %443, label %444, label %452
444: ; preds = %437
%445 = load [30 x i8]*, [30 x i8]** %6
%446 = load i32, i32* %13
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds [30 x i8], [30 x i8]* %445, i64 %447
%449 = load i32, i32* %14
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds [30 x i8], [30 x i8]* %448, i64 0, i64 %450
store i8 68, i8* %451
br label %452
452: ; preds = %444, %437, %434, %425
%453 = load i32, i32* %13
%454 = icmp slt i32 %453, 21
br i1 %454, label %455, label %488
455: ; preds = %452
%456 = load i32, i32* %14
%457 = icmp sgt i32 %456, 0
br i1 %457, label %458, label %488
458: ; preds = %455
%459 = load [30 x i8]*, [30 x i8]** %6
%460 = bitcast [30 x i8]* %459 to i8**
%461 = load i32, i32* %13
%462 = load i32, i32* %14
%463 = call i64 @validate_position(i8** %460, i32 %461, i32 %462)
%464 = icmp ne i64 %463, 0
br i1 %464, label %488, label %465
465: ; preds = %458
br label %466
466: ; preds = %477, %465
%467 = load [30 x i8]*, [30 x i8]** %6
%468 = load i32, i32* %13
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds [30 x i8], [30 x i8]* %467, i64 %469
%471 = load i32, i32* %14
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds [30 x i8], [30 x i8]* %470, i64 0, i64 %472
%474 = load i8, i8* %473
%475 = sext i8 %474 to i32
%476 = icmp ne i32 %475, 32
br i1 %476, label %477, label %480
477: ; preds = %466
%478 = load i32, i32* %14
%479 = add nsw i32 %478, 1
store i32 %479, i32* %14
br label %466
480: ; preds = %466
%481 = load [30 x i8]*, [30 x i8]** %6
%482 = load i32, i32* %13
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [30 x i8], [30 x i8]* %481, i64 %483
%485 = load i32, i32* %14
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds [30 x i8], [30 x i8]* %484, i64 0, i64 %486
store i8 68, i8* %487
br label %488
488: ; preds = %480, %458, %455, %452
%489 = load i32, i32* %14
%490 = icmp sle i32 %489, 0
br i1 %490, label %491, label %558
491: ; preds = %488
%492 = load i32, i32* %13
%493 = load i32, i32* %14
%494 = add nsw i32 %492, %493
store i32 %494, i32* %13
%495 = load i32, i32* %13
%496 = icmp sgt i32 %495, 0
br i1 %496, label %497, label %509
497: ; preds = %491
%498 = load [30 x i8]*, [30 x i8]** %6
%499 = bitcast [30 x i8]* %498 to i8**
%500 = load i32, i32* %13
%501 = call i64 @validate_position(i8** %499, i32 %500, i32 1)
%502 = icmp ne i64 %501, 0
br i1 %502, label %503, label %509
503: ; preds = %497
%504 = load [30 x i8]*, [30 x i8]** %6
%505 = load i32, i32* %13
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds [30 x i8], [30 x i8]* %504, i64 %506
%508 = getelementptr inbounds [30 x i8], [30 x i8]* %507, i64 0, i64 1
store i8 68, i8* %508
br label %557
509: ; preds = %497, %491
%510 = load i32, i32* %13
%511 = icmp sgt i32 %510, 0
br i1 %511, label %512, label %541
512: ; preds = %509
%513 = load [30 x i8]*, [30 x i8]** %6
%514 = bitcast [30 x i8]* %513 to i8**
%515 = load i32, i32* %13
%516 = call i64 @validate_position(i8** %514, i32 %515, i32 1)
%517 = icmp ne i64 %516, 0
br i1 %517, label %541, label %518
518: ; preds = %512
br label %519
519: ; preds = %530, %518
%520 = load [30 x i8]*, [30 x i8]** %6
%521 = load i32, i32* %13
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds [30 x i8], [30 x i8]* %520, i64 %522
%524 = load i32, i32* %14
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [30 x i8], [30 x i8]* %523, i64 0, i64 %525
%527 = load i8, i8* %526
%528 = sext i8 %527 to i32
%529 = icmp ne i32 %528, 32
br i1 %529, label %530, label %533
530: ; preds = %519
%531 = load i32, i32* %13
%532 = add nsw i32 %531, 1
store i32 %532, i32* %13
br label %519
533: ; preds = %519
%534 = load [30 x i8]*, [30 x i8]** %6
%535 = load i32, i32* %13
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds [30 x i8], [30 x i8]* %534, i64 %536
%538 = load i32, i32* %14
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds [30 x i8], [30 x i8]* %537, i64 0, i64 %539
store i8 68, i8* %540
br label %556
541: ; preds = %512, %509
br label %542
542: ; preds = %545, %541
%543 = load i32, i32* %14
%544 = icmp slt i32 %543, 1
br i1 %544, label %545, label %548
545: ; preds = %542
%546 = load i32, i32* %14
%547 = add nsw i32 %546, 1
store i32 %547, i32* %14
br label %542
548: ; preds = %542
%549 = load [30 x i8]*, [30 x i8]** %6
%550 = load i32, i32* %13
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds [30 x i8], [30 x i8]* %549, i64 %551
%553 = load i32, i32* %14
%554 = sext i32 %553 to i64
%555 = getelementptr inbounds [30 x i8], [30 x i8]* %552, i64 0, i64 %554
store i8 68, i8* %555
br label %556
556: ; preds = %548, %533
br label %557
557: ; preds = %556, %503
br label %558
558: ; preds = %557, %488
%559 = load i32, i32* %13
%560 = icmp sle i32 %559, 0
br i1 %560, label %561, label %625
561: ; preds = %558
%562 = load i32, i32* %14
%563 = load i32, i32* %13
%564 = add nsw i32 %562, %563
store i32 %564, i32* %14
%565 = load i32, i32* %14
%566 = icmp sgt i32 %565, 0
br i1 %566, label %567, label %579
567: ; preds = %561
%568 = load [30 x i8]*, [30 x i8]** %6
%569 = bitcast [30 x i8]* %568 to i8**
%570 = load i32, i32* %14
%571 = call i64 @validate_position(i8** %569, i32 1, i32 %570)
%572 = icmp ne i64 %571, 0
br i1 %572, label %573, label %579
573: ; preds = %567
%574 = load [30 x i8]*, [30 x i8]** %6
%575 = getelementptr inbounds [30 x i8], [30 x i8]* %574, i64 1
%576 = load i32, i32* %14
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds [30 x i8], [30 x i8]* %575, i64 0, i64 %577
store i8 68, i8* %578
br label %579
579: ; preds = %573, %567, %561
%580 = load i32, i32* %14
%581 = icmp sgt i32 %580, 0
br i1 %581, label %582, label %609
582: ; preds = %579
%583 = load [30 x i8]*, [30 x i8]** %6
%584 = bitcast [30 x i8]* %583 to i8**
%585 = load i32, i32* %14
%586 = call i64 @validate_position(i8** %584, i32 1, i32 %585)
%587 = icmp ne i64 %586, 0
br i1 %587, label %609, label %588
588: ; preds = %582
br label %589
589: ; preds = %600, %588
%590 = load [30 x i8]*, [30 x i8]** %6
%591 = load i32, i32* %13
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds [30 x i8], [30 x i8]* %590, i64 %592
%594 = load i32, i32* %14
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds [30 x i8], [30 x i8]* %593, i64 0, i64 %595
%597 = load i8, i8* %596
%598 = sext i8 %597 to i32
%599 = icmp ne i32 %598, 32
br i1 %599, label %600, label %603
600: ; preds = %589
%601 = load i32, i32* %14
%602 = add nsw i32 %601, 1
store i32 %602, i32* %14
br label %589
603: ; preds = %589
%604 = load [30 x i8]*, [30 x i8]** %6
%605 = getelementptr inbounds [30 x i8], [30 x i8]* %604, i64 1
%606 = load i32, i32* %14
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds [30 x i8], [30 x i8]* %605, i64 0, i64 %607
store i8 68, i8* %608
br label %624
609: ; preds = %582, %579
br label %610
610: ; preds = %613, %609
%611 = load i32, i32* %13
%612 = icmp slt i32 %611, 1
br i1 %612, label %613, label %616
613: ; preds = %610
%614 = load i32, i32* %13
%615 = add nsw i32 %614, -1
store i32 %615, i32* %13
br label %610
616: ; preds = %610
%617 = load [30 x i8]*, [30 x i8]** %6
%618 = load i32, i32* %13
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds [30 x i8], [30 x i8]* %617, i64 %619
%621 = load i32, i32* %14
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds [30 x i8], [30 x i8]* %620, i64 0, i64 %622
store i8 68, i8* %623
br label %624
624: ; preds = %616, %603
br label %625
625: ; preds = %624, %558
br label %626
626: ; preds = %625, %422, %419
%627 = load i32, i32* %11
%628 = icmp slt i32 %627, 0
br i1 %628, label %629, label %833
629: ; preds = %626
%630 = load i32, i32* %12
%631 = icmp sgt i32 %630, 0
br i1 %631, label %632, label %833
632: ; preds = %629
%633 = load i32, i32* %7
%634 = load i32, i32* %11
%635 = add nsw i32 %633, %634
store i32 %635, i32* %13
%636 = load i32, i32* %8
%637 = load i32, i32* %12
%638 = add nsw i32 %636, %637
store i32 %638, i32* %14
%639 = load i32, i32* %13
%640 = icmp sgt i32 %639, 0
br i1 %640, label %641, label %659
641: ; preds = %632
%642 = load i32, i32* %14
%643 = icmp slt i32 %642, 28
br i1 %643, label %644, label %659
644: ; preds = %641
%645 = load [30 x i8]*, [30 x i8]** %6
%646 = bitcast [30 x i8]* %645 to i8**
%647 = load i32, i32* %13
%648 = load i32, i32* %14
%649 = call i64 @validate_position(i8** %646, i32 %647, i32 %648)
%650 = icmp ne i64 %649, 0
br i1 %650, label %651, label %659
651: ; preds = %644
%652 = load [30 x i8]*, [30 x i8]** %6
%653 = load i32, i32* %13
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds [30 x i8], [30 x i8]* %652, i64 %654
%656 = load i32, i32* %14
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds [30 x i8], [30 x i8]* %655, i64 0, i64 %657
store i8 68, i8* %658
br label %659
659: ; preds = %651, %644, %641, %632
%660 = load i32, i32* %13
%661 = icmp sgt i32 %660, 0
br i1 %661, label %662, label %695
662: ; preds = %659
%663 = load i32, i32* %14
%664 = icmp sle i32 %663, 28
br i1 %664, label %665, label %695
665: ; preds = %662
%666 = load [30 x i8]*, [30 x i8]** %6
%667 = bitcast [30 x i8]* %666 to i8**
%668 = load i32, i32* %13
%669 = load i32, i32* %14
%670 = call i64 @validate_position(i8** %667, i32 %668, i32 %669)
%671 = icmp ne i64 %670, 0
br i1 %671, label %695, label %672
672: ; preds = %665
br label %673
673: ; preds = %684, %672
%674 = load [30 x i8]*, [30 x i8]** %6
%675 = load i32, i32* %13
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds [30 x i8], [30 x i8]* %674, i64 %676
%678 = load i32, i32* %14
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds [30 x i8], [30 x i8]* %677, i64 0, i64 %679
%681 = load i8, i8* %680
%682 = sext i8 %681 to i32
%683 = icmp ne i32 %682, 32
br i1 %683, label %684, label %687
684: ; preds = %673
%685 = load i32, i32* %13
%686 = add nsw i32 %685, -1
store i32 %686, i32* %13
br label %673
687: ; preds = %673
%688 = load [30 x i8]*, [30 x i8]** %6
%689 = load i32, i32* %13
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds [30 x i8], [30 x i8]* %688, i64 %690
%692 = load i32, i32* %14
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds [30 x i8], [30 x i8]* %691, i64 0, i64 %693
store i8 68, i8* %694
br label %695
695: ; preds = %687, %665, %662, %659
%696 = load i32, i32* %14
%697 = icmp sle i32 %696, 0
br i1 %697, label %698, label %765
698: ; preds = %695
%699 = load i32, i32* %13
%700 = load i32, i32* %14
%701 = add nsw i32 %699, %700
store i32 %701, i32* %13
%702 = load i32, i32* %13
%703 = icmp sgt i32 %702, 0
br i1 %703, label %704, label %716
704: ; preds = %698
%705 = load [30 x i8]*, [30 x i8]** %6
%706 = bitcast [30 x i8]* %705 to i8**
%707 = load i32, i32* %13
%708 = call i64 @validate_position(i8** %706, i32 %707, i32 1)
%709 = icmp ne i64 %708, 0
br i1 %709, label %710, label %716
710: ; preds = %704
%711 = load [30 x i8]*, [30 x i8]** %6
%712 = load i32, i32* %13
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds [30 x i8], [30 x i8]* %711, i64 %713
%715 = getelementptr inbounds [30 x i8], [30 x i8]* %714, i64 0, i64 1
store i8 68, i8* %715
br label %764
716: ; preds = %704, %698
%717 = load i32, i32* %13
%718 = icmp sgt i32 %717, 0
br i1 %718, label %719, label %748
719: ; preds = %716
%720 = load [30 x i8]*, [30 x i8]** %6
%721 = bitcast [30 x i8]* %720 to i8**
%722 = load i32, i32* %13
%723 = call i64 @validate_position(i8** %721, i32 %722, i32 1)
%724 = icmp ne i64 %723, 0
br i1 %724, label %748, label %725
725: ; preds = %719
br label %726
726: ; preds = %737, %725
%727 = load [30 x i8]*, [30 x i8]** %6
%728 = load i32, i32* %13
%729 = sext i32 %728 to i64
%730 = getelementptr inbounds [30 x i8], [30 x i8]* %727, i64 %729
%731 = load i32, i32* %14
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds [30 x i8], [30 x i8]* %730, i64 0, i64 %732
%734 = load i8, i8* %733
%735 = sext i8 %734 to i32
%736 = icmp ne i32 %735, 32
br i1 %736, label %737, label %740
737: ; preds = %726
%738 = load i32, i32* %13
%739 = add nsw i32 %738, 1
store i32 %739, i32* %13
br label %726
740: ; preds = %726
%741 = load [30 x i8]*, [30 x i8]** %6
%742 = load i32, i32* %13
%743 = sext i32 %742 to i64
%744 = getelementptr inbounds [30 x i8], [30 x i8]* %741, i64 %743
%745 = load i32, i32* %14
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds [30 x i8], [30 x i8]* %744, i64 0, i64 %746
store i8 68, i8* %747
br label %763
748: ; preds = %719, %716
br label %749
749: ; preds = %752, %748
%750 = load i32, i32* %14
%751 = icmp slt i32 %750, 1
br i1 %751, label %752, label %755
752: ; preds = %749
%753 = load i32, i32* %14
%754 = add nsw i32 %753, 1
store i32 %754, i32* %14
br label %749
755: ; preds = %749
%756 = load [30 x i8]*, [30 x i8]** %6
%757 = load i32, i32* %13
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds [30 x i8], [30 x i8]* %756, i64 %758
%760 = load i32, i32* %14
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds [30 x i8], [30 x i8]* %759, i64 0, i64 %761
store i8 68, i8* %762
br label %763
763: ; preds = %755, %740
br label %764
764: ; preds = %763, %710
br label %765
765: ; preds = %764, %695
%766 = load i32, i32* %13
%767 = icmp sle i32 %766, 0
br i1 %767, label %768, label %832
768: ; preds = %765
%769 = load i32, i32* %14
%770 = load i32, i32* %13
%771 = add nsw i32 %769, %770
store i32 %771, i32* %14
%772 = load i32, i32* %14
%773 = icmp sgt i32 %772, 0
br i1 %773, label %774, label %786
774: ; preds = %768
%775 = load [30 x i8]*, [30 x i8]** %6
%776 = bitcast [30 x i8]* %775 to i8**
%777 = load i32, i32* %14
%778 = call i64 @validate_position(i8** %776, i32 1, i32 %777)
%779 = icmp ne i64 %778, 0
br i1 %779, label %780, label %786
780: ; preds = %774
%781 = load [30 x i8]*, [30 x i8]** %6
%782 = getelementptr inbounds [30 x i8], [30 x i8]* %781, i64 1
%783 = load i32, i32* %14
%784 = sext i32 %783 to i64
%785 = getelementptr inbounds [30 x i8], [30 x i8]* %782, i64 0, i64 %784
store i8 68, i8* %785
br label %786
786: ; preds = %780, %774, %768
%787 = load i32, i32* %14
%788 = icmp sgt i32 %787, 0
br i1 %788, label %789, label %816
789: ; preds = %786
%790 = load [30 x i8]*, [30 x i8]** %6
%791 = bitcast [30 x i8]* %790 to i8**
%792 = load i32, i32* %14
%793 = call i64 @validate_position(i8** %791, i32 1, i32 %792)
%794 = icmp ne i64 %793, 0
br i1 %794, label %816, label %795
795: ; preds = %789
br label %796
796: ; preds = %807, %795
%797 = load [30 x i8]*, [30 x i8]** %6
%798 = load i32, i32* %13
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds [30 x i8], [30 x i8]* %797, i64 %799
%801 = load i32, i32* %14
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds [30 x i8], [30 x i8]* %800, i64 0, i64 %802
%804 = load i8, i8* %803
%805 = sext i8 %804 to i32
%806 = icmp ne i32 %805, 32
br i1 %806, label %807, label %810
807: ; preds = %796
%808 = load i32, i32* %14
%809 = add nsw i32 %808, 1
store i32 %809, i32* %14
br label %796
810: ; preds = %796
%811 = load [30 x i8]*, [30 x i8]** %6
%812 = getelementptr inbounds [30 x i8], [30 x i8]* %811, i64 1
%813 = load i32, i32* %14
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds [30 x i8], [30 x i8]* %812, i64 0, i64 %814
store i8 68, i8* %815
br label %831
816: ; preds = %789, %786
br label %817
817: ; preds = %820, %816
%818 = load i32, i32* %13
%819 = icmp slt i32 %818, 1
br i1 %819, label %820, label %823
820: ; preds = %817
%821 = load i32, i32* %13
%822 = add nsw i32 %821, -1
store i32 %822, i32* %13
br label %817
823: ; preds = %817
%824 = load [30 x i8]*, [30 x i8]** %6
%825 = load i32, i32* %13
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds [30 x i8], [30 x i8]* %824, i64 %826
%828 = load i32, i32* %14
%829 = sext i32 %828 to i64
%830 = getelementptr inbounds [30 x i8], [30 x i8]* %827, i64 0, i64 %829
store i8 68, i8* %830
br label %831
831: ; preds = %823, %810
br label %832
832: ; preds = %831, %765
br label %833
833: ; preds = %832, %629, %626
%834 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
ret void
}

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