#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 *, ...);
void print_matrix(unsigned char m[7][31]) {
  int i, j;
  for (i = 0; i < 7; i++) {
    for (j = 0; j < 31; j++) {
      printf("%02x ", m[i][j]);
    }
    printf("\n");
  }
  return;
}


x86 assembly (clang, -O0):
<print_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x7,-0xc(%rbp)
jge    118d <print_matrix+0x7d>
movl   $0x0,-0x10(%rbp)
cmpl   $0x1f,-0x10(%rbp)
jge    1171 <print_matrix+0x61>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x1f,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
lea    0xea4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1134 <print_matrix+0x24>
lea    0xe8e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1123 <print_matrix+0x13>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<print_matrix>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
movzbl (%rdi),%esi
lea    0xecf(%rip),%r14
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xe(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xf(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x10(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x11(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x12(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x13(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x14(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x15(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x16(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x17(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x18(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x19(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x1e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0x1f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x20(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x21(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x22(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x23(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x24(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x25(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x26(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x27(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x28(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x29(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x2f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x30(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x31(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x32(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x33(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x34(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x35(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x36(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x37(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x38(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x39(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0x3e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x3f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x40(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x41(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x42(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x43(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x44(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x45(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x46(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x47(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x48(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x49(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x4f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x50(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x51(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x52(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x53(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x54(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x55(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x56(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x57(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x58(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x59(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0x5d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x5f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x60(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x61(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x62(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x63(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x64(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x65(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x66(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x67(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x68(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x69(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x6f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x70(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x71(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x72(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x73(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x74(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x75(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x76(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x77(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x78(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x79(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0x7c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x7f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x80(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x81(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x82(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x83(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x84(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x85(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x86(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x87(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x88(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x89(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x8f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x90(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x91(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x92(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x93(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x94(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x95(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x96(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x97(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x98(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x99(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9a(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0x9b(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9c(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9d(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9e(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0x9f(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa0(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa1(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa2(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa3(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa4(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa5(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa6(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa7(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa8(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xa9(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xaa(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xab(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xac(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xad(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xae(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xaf(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb0(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb1(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb2(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb3(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb4(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb5(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb6(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb7(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb8(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xb9(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movzbl 0xba(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xbb(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xbc(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xbd(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xbe(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xbf(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc0(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc1(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc2(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc3(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc4(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc5(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc6(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc7(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc8(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xc9(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xca(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xcb(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xcc(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xcd(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xce(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xcf(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd0(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd1(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd2(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd3(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd4(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd5(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd6(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd7(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movzbl 0xd8(%rbx),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
add    $0x8,%rsp
pop    %rbx
pop    %r14
jmp    1030 <putchar@plt>

LLVM IR (-O0):
@.str = [6 x i8] c"%02x \00"
@.str.1 = [2 x i8] c"\0A\00"
define void @print_matrix([31 x i8]* %0) {
%2 = alloca [31 x i8]*
%3 = alloca i32
%4 = alloca i32
store [31 x i8]* %0, [31 x i8]** %2
store i32 0, i32* %3
br label %5
5: ; preds = %28, %1
%6 = load i32, i32* %3
%7 = icmp slt i32 %6, 7
br i1 %7, label %8, label %31
8: ; preds = %5
store i32 0, i32* %4
br label %9
9: ; preds = %23, %8
%10 = load i32, i32* %4
%11 = icmp slt i32 %10, 31
br i1 %11, label %12, label %26
12: ; preds = %9
%13 = load [31 x i8]*, [31 x i8]** %2
%14 = load i32, i32* %3
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [31 x i8], [31 x i8]* %13, i64 %15
%17 = load i32, i32* %4
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [31 x i8], [31 x i8]* %16, i64 0, i64 %18
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i32 %21)
br label %23
23: ; preds = %12
%24 = load i32, i32* %4
%25 = add nsw i32 %24, 1
store i32 %25, i32* %4
br label %9
26: ; preds = %9
%27 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %28
28: ; preds = %26
%29 = load i32, i32* %3
%30 = add nsw i32 %29, 1
store i32 %30, i32* %3
br label %5
31: ; preds = %5
ret void
}

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