#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*/ ft_putchar(char);
int /*<<< orphan*/ ft_putnbr(char);
int /*<<< orphan*/ ft_putstr(char *);
int main(int ac, char **av) {
  char tab[9][9];
  char x;
  char y;
  char compt;
  y = 0;
  compt = 0;
  if (ac == 10) {
    while (y < 9) {
      x = 0;
      while (x < 9) {
        ((av[y + 1][x] != '.') ? tab[x][y] = av[y + 1][x] : compt++);
        ((av[y + 1][x] != '.') ? 0 : (tab[x][y] = '0'));
        x++;
      }
      y++;
    }
  }
  if ((compt > 64) || (ac != 10))
    ft_putstr("Erreur\n");
  ft_putnbr(compt);
  ft_putchar('\n');
  x = 0;
  y = 0;
  while (y <= 8) {
    x = 0;
    while (x <= 8) {
      ft_putchar(tab[x][y]);
      (x != 8) ? ft_putchar(' ') : 0;
      x++;
    }
    ft_putchar('\n');
    y++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movb   $0x0,-0x72(%rbp)
movb   $0x0,-0x73(%rbp)
cmpl   $0xa,-0x8(%rbp)
jne    124b <main+0x11b>
jmp    1160 <main+0x30>
movsbl -0x72(%rbp),%eax
cmp    $0x9,%eax
jge    1246 <main+0x116>
movb   $0x0,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x9,%eax
jge    1239 <main+0x109>
mov    -0x10(%rbp),%rax
movsbl -0x72(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movsbq -0x71(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     11dc <main+0xac>
mov    -0x10(%rbp),%rax
movsbl -0x72(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movsbq -0x71(%rbp),%rcx
mov    (%rax,%rcx,1),%al
movsbq -0x71(%rbp),%rdx
lea    -0x70(%rbp),%rcx
imul   $0x9,%rdx,%rdx
add    %rdx,%rcx
movsbq -0x72(%rbp),%rdx
mov    %al,(%rcx,%rdx,1)
movsbl %al,%eax
jmp    11ea <main+0xba>
mov    -0x73(%rbp),%al
mov    %al,%cl
add    $0x1,%cl
mov    %cl,-0x73(%rbp)
movsbl %al,%eax
mov    -0x10(%rbp),%rax
movsbl -0x72(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movsbq -0x71(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
je     1213 <main+0xe3>
jmp    122c <main+0xfc>
movsbq -0x71(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movsbq -0x72(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x71(%rbp),%al
add    $0x1,%al
mov    %al,-0x71(%rbp)
jmp    1171 <main+0x41>
mov    -0x72(%rbp),%al
add    $0x1,%al
mov    %al,-0x72(%rbp)
jmp    1160 <main+0x30>
jmp    124b <main+0x11b>
movsbl -0x73(%rbp),%eax
cmp    $0x40,%eax
jg     1262 <main+0x132>
cmpl   $0xa,-0x8(%rbp)
je     126e <main+0x13e>
lea    0xd97(%rip),%rdi
call   1050 <ft_putstr@plt>
movsbl -0x73(%rbp),%edi
call   1040 <ft_putnbr@plt>
mov    $0xa,%edi
call   1030 <ft_putchar@plt>
movb   $0x0,-0x71(%rbp)
movb   $0x0,-0x72(%rbp)
movsbl -0x72(%rbp),%eax
cmp    $0x8,%eax
jg     130a <main+0x1da>
movb   $0x0,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x8,%eax
jg     12f3 <main+0x1c3>
movsbq -0x71(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movsbq -0x72(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <ft_putchar@plt>
movsbl -0x71(%rbp),%eax
cmp    $0x8,%eax
je     12e1 <main+0x1b1>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
jmp    12e6 <main+0x1b6>
jmp    12e6 <main+0x1b6>
mov    -0x71(%rbp),%al
add    $0x1,%al
mov    %al,-0x71(%rbp)
jmp    129a <main+0x16a>
mov    $0xa,%edi
call   1030 <ft_putchar@plt>
mov    -0x72(%rbp),%al
add    $0x1,%al
mov    %al,-0x72(%rbp)
jmp    1289 <main+0x159>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0x58,%rsp
cmp    $0xa,%edi
jne    124e <main+0x11e>
xor    %ecx,%ecx
movdqa 0xeb7(%rip),%xmm0
mov    $0x30,%r8d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsi,%rcx,8),%r9
mov    (%r9),%rbx
movq   %rbx,%xmm1
pcmpeqb %xmm0,%xmm1
pmovmskb %xmm1,%edx
test   $0x1,%dl
mov    %ebx,%edi
cmovne %r8d,%edi
mov    %rbx,%rax
shr    $0x8,%rax
test   $0x2,%dl
cmovne %r8d,%eax
mov    %dil,(%rsp,%rcx,1)
mov    %al,0x9(%rsp,%rcx,1)
mov    %rbx,%rax
shr    $0x10,%rax
test   $0x4,%dl
cmovne %r8d,%eax
mov    %al,0x12(%rsp,%rcx,1)
mov    %rbx,%rax
shr    $0x18,%rax
test   $0x8,%dl
cmovne %r8d,%eax
mov    %al,0x1b(%rsp,%rcx,1)
mov    %rbx,%rax
shr    $0x20,%rax
test   $0x10,%dl
cmovne %r8d,%eax
mov    %rbx,%rdi
shr    $0x28,%rdi
test   $0x20,%dl
cmovne %r8d,%edi
mov    %al,0x24(%rsp,%rcx,1)
mov    %dil,0x2d(%rsp,%rcx,1)
mov    %rbx,%rax
shr    $0x30,%rax
test   $0x40,%dl
cmovne %r8d,%eax
mov    %al,0x36(%rsp,%rcx,1)
shr    $0x38,%rbx
test   $0x80,%dl
cmovne %r8d,%ebx
mov    %bl,0x3f(%rsp,%rcx,1)
movzbl 0x8(%r9),%eax
cmp    $0x2e,%al
cmove  %r8d,%eax
mov    %al,0x48(%rsp,%rcx,1)
lea    0x1(%rcx),%rax
sete   %cl
mov    %edx,%ebx
shr    %bl
and    $0x55,%bl
sub    %bl,%dl
mov    %edx,%ebx
and    $0x33,%bl
shr    $0x2,%dl
and    $0x33,%dl
add    %bl,%dl
mov    %edx,%ebx
shr    $0x4,%bl
add    %dl,%bl
and    $0xf,%bl
add    %cl,%bl
add    %bl,%bpl
mov    %rax,%rcx
cmp    $0x9,%rax
jne    1160 <main+0x30>
cmp    $0x41,%bpl
jge    1250 <main+0x120>
jmp    125c <main+0x12c>
xor    %ebp,%ebp
lea    0xdb9(%rip),%rdi
call   1050 <ft_putstr@plt>
movsbl %bpl,%edi
call   1040 <ft_putnbr@plt>
mov    $0xa,%edi
call   1030 <ft_putchar@plt>
mov    $0xfffffffffffffff7,%rbx
cs nopw 0x0(%rax,%rax,1)
movsbl 0x9(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x12(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x1b(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x24(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x2d(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x36(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x3f(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x48(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0x20,%edi
call   1030 <ft_putchar@plt>
movsbl 0x51(%rsp,%rbx,1),%edi
call   1030 <ft_putchar@plt>
mov    $0xa,%edi
call   1030 <ft_putchar@plt>
inc    %rbx
jne    1280 <main+0x150>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@.str = [8 x i8] c"Erreur\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [9 x [9 x i8]]
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i8 0, i8* %8
store i8 0, i8* %9
%10 = load i32, i32* %4
%11 = icmp eq i32 %10, 10
br i1 %11, label %12, label %90
12: ; preds = %2
br label %13
13: ; preds = %86, %12
%14 = load i8, i8* %8
%15 = sext i8 %14 to i32
%16 = icmp slt i32 %15, 9
br i1 %16, label %17, label %89
17: ; preds = %13
store i8 0, i8* %7
br label %18
18: ; preds = %82, %17
%19 = load i8, i8* %7
%20 = sext i8 %19 to i32
%21 = icmp slt i32 %20, 9
br i1 %21, label %22, label %86
22: ; preds = %18
%23 = load i8**, i8*** %5
%24 = load i8, i8* %8
%25 = sext i8 %24 to i32
%26 = add nsw i32 %25, 1
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8*, i8** %23, i64 %27
%29 = load i8*, i8** %28
%30 = load i8, i8* %7
%31 = sext i8 %30 to i64
%32 = getelementptr inbounds i8, i8* %29, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp ne i32 %34, 46
br i1 %35, label %36, label %55
36: ; preds = %22
%37 = load i8**, i8*** %5
%38 = load i8, i8* %8
%39 = sext i8 %38 to i32
%40 = add nsw i32 %39, 1
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8*, i8** %37, i64 %41
%43 = load i8*, i8** %42
%44 = load i8, i8* %7
%45 = sext i8 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = load i8, i8* %7
%49 = sext i8 %48 to i64
%50 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %6, i64 0, i64 %49
%51 = load i8, i8* %8
%52 = sext i8 %51 to i64
%53 = getelementptr inbounds [9 x i8], [9 x i8]* %50, i64 0, i64 %52
store i8 %47, i8* %53
%54 = sext i8 %47 to i32
br label %59
55: ; preds = %22
%56 = load i8, i8* %9
%57 = add i8 %56, 1
store i8 %57, i8* %9
%58 = sext i8 %56 to i32
br label %59
59: ; preds = %55, %36
%60 = phi i32 [ %54, %36 ], [ %58, %55 ]
%61 = load i8**, i8*** %5
%62 = load i8, i8* %8
%63 = sext i8 %62 to i32
%64 = add nsw i32 %63, 1
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8*, i8** %61, i64 %65
%67 = load i8*, i8** %66
%68 = load i8, i8* %7
%69 = sext i8 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
%73 = icmp ne i32 %72, 46
br i1 %73, label %74, label %75
74: ; preds = %59
br label %82
75: ; preds = %59
%76 = load i8, i8* %7
%77 = sext i8 %76 to i64
%78 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %6, i64 0, i64 %77
%79 = load i8, i8* %8
%80 = sext i8 %79 to i64
%81 = getelementptr inbounds [9 x i8], [9 x i8]* %78, i64 0, i64 %80
store i8 48, i8* %81
br label %82
82: ; preds = %75, %74
%83 = phi i32 [ 0, %74 ], [ 48, %75 ]
%84 = load i8, i8* %7
%85 = add i8 %84, 1
store i8 %85, i8* %7
br label %18
86: ; preds = %18
%87 = load i8, i8* %8
%88 = add i8 %87, 1
store i8 %88, i8* %8
br label %13
89: ; preds = %13
br label %90
90: ; preds = %89, %2
%91 = load i8, i8* %9
%92 = sext i8 %91 to i32
%93 = icmp sgt i32 %92, 64
br i1 %93, label %97, label %94
94: ; preds = %90
%95 = load i32, i32* %4
%96 = icmp ne i32 %95, 10
br i1 %96, label %97, label %99
97: ; preds = %94, %90
%98 = call i32 @ft_putstr(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
br label %99
99: ; preds = %97, %94
%100 = load i8, i8* %9
%101 = call i32 @ft_putnbr(i8 signext %100)
%102 = call i32 @ft_putchar(i8 signext 10)
store i8 0, i8* %7
store i8 0, i8* %8
br label %103
103: ; preds = %131, %99
%104 = load i8, i8* %8
%105 = sext i8 %104 to i32
%106 = icmp sle i32 %105, 8
br i1 %106, label %107, label %135
107: ; preds = %103
store i8 0, i8* %7
br label %108
108: ; preds = %127, %107
%109 = load i8, i8* %7
%110 = sext i8 %109 to i32
%111 = icmp sle i32 %110, 8
br i1 %111, label %112, label %131
112: ; preds = %108
%113 = load i8, i8* %7
%114 = sext i8 %113 to i64
%115 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %6, i64 0, i64 %114
%116 = load i8, i8* %8
%117 = sext i8 %116 to i64
%118 = getelementptr inbounds [9 x i8], [9 x i8]* %115, i64 0, i64 %117
%119 = load i8, i8* %118
%120 = call i32 @ft_putchar(i8 signext %119)
%121 = load i8, i8* %7
%122 = sext i8 %121 to i32
%123 = icmp ne i32 %122, 8
br i1 %123, label %124, label %126
124: ; preds = %112
%125 = call i32 @ft_putchar(i8 signext 32)
br label %127
126: ; preds = %112
br label %127
127: ; preds = %126, %124
%128 = phi i32 [ %125, %124 ], [ 0, %126 ]
%129 = load i8, i8* %7
%130 = add i8 %129, 1
store i8 %130, i8* %7
br label %108
131: ; preds = %108
%132 = call i32 @ft_putchar(i8 signext 10)
%133 = load i8, i8* %8
%134 = add i8 %133, 1
store i8 %134, i8* %8
br label %103
135: ; preds = %103
ret i32 0
}

LLVM IR (-O2):
@.str = [8 x i8] c"Erreur\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [9 x [9 x i8]]
%4 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 0, i64 0
%5 = icmp eq i32 %0, 10
br i1 %5, label %6, label %60
6: ; preds = %2, %6
%7 = phi i64 [ %9, %6 ], [ 0, %2 ]
%8 = phi i8 [ %55, %6 ], [ 0, %2 ]
%9 = add nuw nsw i64 %7, 1
%10 = getelementptr inbounds i8*, i8** %1, i64 %9
%11 = load i8*, i8** %10
%12 = bitcast i8* %11 to <8 x i8>*
%13 = load <8 x i8>, <8 x i8>* %12
%14 = icmp eq <8 x i8> %13, <i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46, i8 46>
%15 = extractelement <8 x i1> %14, i64 0
%16 = extractelement <8 x i8> %13, i64 0
%17 = select i1 %15, i8 48, i8 %16
%18 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 0, i64 %7
store i8 %17, i8* %18
%19 = extractelement <8 x i1> %14, i64 1
%20 = extractelement <8 x i8> %13, i64 1
%21 = select i1 %19, i8 48, i8 %20
%22 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 1, i64 %7
store i8 %21, i8* %22
%23 = extractelement <8 x i1> %14, i64 2
%24 = extractelement <8 x i8> %13, i64 2
%25 = select i1 %23, i8 48, i8 %24
%26 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 2, i64 %7
store i8 %25, i8* %26
%27 = extractelement <8 x i1> %14, i64 3
%28 = extractelement <8 x i8> %13, i64 3
%29 = select i1 %27, i8 48, i8 %28
%30 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 3, i64 %7
store i8 %29, i8* %30
%31 = extractelement <8 x i1> %14, i64 4
%32 = extractelement <8 x i8> %13, i64 4
%33 = select i1 %31, i8 48, i8 %32
%34 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 4, i64 %7
store i8 %33, i8* %34
%35 = extractelement <8 x i1> %14, i64 5
%36 = extractelement <8 x i8> %13, i64 5
%37 = select i1 %35, i8 48, i8 %36
%38 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 5, i64 %7
store i8 %37, i8* %38
%39 = extractelement <8 x i1> %14, i64 6
%40 = extractelement <8 x i8> %13, i64 6
%41 = select i1 %39, i8 48, i8 %40
%42 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 6, i64 %7
store i8 %41, i8* %42
%43 = extractelement <8 x i1> %14, i64 7
%44 = extractelement <8 x i8> %13, i64 7
%45 = select i1 %43, i8 48, i8 %44
%46 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 7, i64 %7
store i8 %45, i8* %46
%47 = getelementptr inbounds i8, i8* %11, i64 8
%48 = load i8, i8* %47
%49 = icmp eq i8 %48, 46
%50 = select i1 %49, i8 48, i8 %48
%51 = zext i1 %49 to i8
%52 = bitcast <8 x i1> %14 to i8
%53 = call i8 @llvm.ctpop.i8(i8 %52)
%54 = add nuw nsw i8 %53, %51
%55 = add i8 %54, %8
%56 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 8, i64 %7
store i8 %50, i8* %56
%57 = icmp eq i64 %9, 9
br i1 %57, label %58, label %6
58: ; preds = %6
%59 = icmp sgt i8 %55, 64
br i1 %59, label %60, label %63
60: ; preds = %2, %58
%61 = phi i8 [ %55, %58 ], [ 0, %2 ]
%62 = tail call i32 @ft_putstr(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
br label %63
63: ; preds = %58, %60
%64 = phi i8 [ %55, %58 ], [ %61, %60 ]
%65 = tail call i32 @ft_putnbr(i8 signext %64)
%66 = tail call i32 @ft_putchar(i8 signext 10)
br label %67
67: ; preds = %67, %63
%68 = phi i64 [ 0, %63 ], [ %105, %67 ]
%69 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 0, i64 %68
%70 = load i8, i8* %69
%71 = tail call i32 @ft_putchar(i8 signext %70)
%72 = tail call i32 @ft_putchar(i8 signext 32)
%73 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 1, i64 %68
%74 = load i8, i8* %73
%75 = tail call i32 @ft_putchar(i8 signext %74)
%76 = tail call i32 @ft_putchar(i8 signext 32)
%77 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 2, i64 %68
%78 = load i8, i8* %77
%79 = tail call i32 @ft_putchar(i8 signext %78)
%80 = tail call i32 @ft_putchar(i8 signext 32)
%81 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 3, i64 %68
%82 = load i8, i8* %81
%83 = tail call i32 @ft_putchar(i8 signext %82)
%84 = tail call i32 @ft_putchar(i8 signext 32)
%85 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 4, i64 %68
%86 = load i8, i8* %85
%87 = tail call i32 @ft_putchar(i8 signext %86)
%88 = tail call i32 @ft_putchar(i8 signext 32)
%89 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 5, i64 %68
%90 = load i8, i8* %89
%91 = tail call i32 @ft_putchar(i8 signext %90)
%92 = tail call i32 @ft_putchar(i8 signext 32)
%93 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 6, i64 %68
%94 = load i8, i8* %93
%95 = tail call i32 @ft_putchar(i8 signext %94)
%96 = tail call i32 @ft_putchar(i8 signext 32)
%97 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 7, i64 %68
%98 = load i8, i8* %97
%99 = tail call i32 @ft_putchar(i8 signext %98)
%100 = tail call i32 @ft_putchar(i8 signext 32)
%101 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %3, i64 0, i64 8, i64 %68
%102 = load i8, i8* %101
%103 = tail call i32 @ft_putchar(i8 signext %102)
%104 = tail call i32 @ft_putchar(i8 signext 10)
%105 = add nuw nsw i64 %68, 1
%106 = icmp eq i64 %105, 9
br i1 %106, label %107, label %67
107: ; preds = %67
ret i32 0
}