int verifica_somma(char **m, int n) {
  int i, j, sum;
  char **tmp;
  tmp = (char **)malloc(4 * sizeof(char *));
  for (i = 0; i < 4; i++)
    tmp[i] = malloc(n * sizeof(char));
  for (i = 0; i < n; i++)
    tmp[0][i] = '0';
  for (i = 1; i < 4; i++)
    for (j = 0; j < n; j++)
      tmp[i][j] = m[i][j];
  for (i = n - 1; i >= 0; i--) {
    sum = tmp[0][i] + tmp[1][i] + tmp[2][i] - 3 * '0';
    if (sum % 10 != tmp[3][i] - '0')
      return 0;
    if (sum > 9) {
      if (i == 0)
        return 0;
      tmp[0][i - 1] = '1';
    }
  }
  for (i = 0; i < 4; i++)
    free(tmp[i]);
  free(tmp);
  return 1;
}


x86 assembly (clang, -O0):
<verifica_somma>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    $0x20,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1178 <verifica_somma+0x58>
movslq -0x14(%rbp),%rdi
shl    $0x0,%rdi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1144 <verifica_somma+0x24>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a8 <verifica_somma+0x88>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x18(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    117f <verifica_somma+0x5f>
movl   $0x1,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1213 <verifica_somma+0xf3>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1200 <verifica_somma+0xe0>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c0 <verifica_somma+0xa0>
jmp    1205 <verifica_somma+0xe5>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11af <verifica_somma+0x8f>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     12da <verifica_somma+0x1ba>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    0x8(%rcx),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x28(%rbp),%rcx
mov    0x10(%rcx),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
sub    $0x90,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x28(%rbp),%rax
mov    0x18(%rax),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
cmp    %eax,%edx
je     1293 <verifica_somma+0x173>
movl   $0x0,-0x4(%rbp)
jmp    131a <verifica_somma+0x1fa>
cmpl   $0x9,-0x20(%rbp)
jle    12c7 <verifica_somma+0x1a7>
cmpl   $0x0,-0x18(%rbp)
jne    12b3 <verifica_somma+0x193>
movl   $0x0,-0x4(%rbp)
jmp    131a <verifica_somma+0x1fa>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x31,(%rax,%rcx,1)
jmp    12cc <verifica_somma+0x1ac>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    121c <verifica_somma+0xfc>
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    130a <verifica_somma+0x1ea>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12e1 <verifica_somma+0x1c1>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<verifica_somma>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%r12
movslq %esi,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %r12,%rcx
mov    %r14,%r8
mov    %rax,%r12
test   %ebx,%ebx
jle    1614 <verifica_somma+0x4e4>
mov    %ebp,%r14d
mov    %r8,(%rsp)
mov    %r8,%rdi
mov    $0x30,%esi
mov    %r14,%rdx
mov    %rcx,%rbx
call   1040 <memset@plt>
mov    %rbx,%r10
mov    0x8(%rbx),%rax
cmp    $0x8,%ebp
jae    11ae <verifica_somma+0x7e>
xor    %ecx,%ecx
mov    (%rsp),%r8
jmp    12d0 <verifica_somma+0x1a0>
cmp    $0x20,%ebp
jae    11be <verifica_somma+0x8e>
xor    %ecx,%ecx
mov    (%rsp),%r8
jmp    1299 <verifica_somma+0x169>
mov    %r14d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
mov    %ebp,%r9d
cmp    $0x60,%rdi
jae    11e5 <verifica_somma+0xb5>
xor    %edi,%edi
jmp    1251 <verifica_somma+0x121>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,0x0(%r13,%rdi,1)
movups %xmm1,0x10(%r13,%rdi,1)
movups 0x20(%rax,%rdi,1),%xmm0
movups 0x30(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%r13,%rdi,1)
movups %xmm1,0x30(%r13,%rdi,1)
movups 0x40(%rax,%rdi,1),%xmm0
movups 0x50(%rax,%rdi,1),%xmm1
movups %xmm0,0x40(%r13,%rdi,1)
movups %xmm1,0x50(%r13,%rdi,1)
movups 0x60(%rax,%rdi,1),%xmm0
movups 0x70(%rax,%rdi,1),%xmm1
movups %xmm0,0x60(%r13,%rdi,1)
movups %xmm1,0x70(%r13,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    11f0 <verifica_somma+0xc0>
test   %rdx,%rdx
mov    (%rsp),%r8
je     128b <verifica_somma+0x15b>
lea    (%rdi,%r13,1),%rsi
add    $0x10,%rsi
add    %rax,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1270 <verifica_somma+0x140>
cmp    %r14,%rcx
mov    %r9d,%ebp
je     12e2 <verifica_somma+0x1b2>
test   $0x18,%r14b
je     12d0 <verifica_somma+0x1a0>
mov    %rcx,%rdx
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rax,%rdx,1),%rsi
mov    %rsi,0x0(%r13,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    12b0 <verifica_somma+0x180>
cmp    %r14,%rcx
je     12e2 <verifica_somma+0x1b2>
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
mov    %dl,0x0(%r13,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    12d0 <verifica_somma+0x1a0>
test   %ebp,%ebp
jle    1614 <verifica_somma+0x4e4>
mov    0x10(%r10),%rax
cmp    $0x8,%ebp
jae    12fa <verifica_somma+0x1ca>
xor    %ecx,%ecx
jmp    1420 <verifica_somma+0x2f0>
cmp    $0x20,%ebp
jae    1306 <verifica_somma+0x1d6>
xor    %ecx,%ecx
jmp    13e8 <verifica_somma+0x2b8>
mov    %r14d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
mov    %ebp,%ebx
cmp    $0x60,%rdi
jae    132c <verifica_somma+0x1fc>
xor    %edi,%edi
jmp    13a0 <verifica_somma+0x270>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
movups 0x20(%rax,%rdi,1),%xmm0
movups 0x30(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%r15,%rdi,1)
movups %xmm1,0x30(%r15,%rdi,1)
movups 0x40(%rax,%rdi,1),%xmm0
movups 0x50(%rax,%rdi,1),%xmm1
movups %xmm0,0x40(%r15,%rdi,1)
movups %xmm1,0x50(%r15,%rdi,1)
movups 0x60(%rax,%rdi,1),%xmm0
movups 0x70(%rax,%rdi,1),%xmm1
movups %xmm0,0x60(%r15,%rdi,1)
movups %xmm1,0x70(%r15,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1340 <verifica_somma+0x210>
test   %rdx,%rdx
je     13db <verifica_somma+0x2ab>
lea    (%r15,%rdi,1),%rsi
add    $0x10,%rsi
add    %rax,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    13c0 <verifica_somma+0x290>
cmp    %r14,%rcx
mov    %ebx,%ebp
je     1431 <verifica_somma+0x301>
test   $0x18,%r14b
je     1420 <verifica_somma+0x2f0>
mov    %rcx,%rdx
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdx,1),%rsi
mov    %rsi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1400 <verifica_somma+0x2d0>
cmp    %r14,%rcx
je     1431 <verifica_somma+0x301>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
mov    %dl,(%r15,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1420 <verifica_somma+0x2f0>
test   %ebp,%ebp
jle    1614 <verifica_somma+0x4e4>
mov    0x18(%r10),%rax
cmp    $0x8,%ebp
jae    1449 <verifica_somma+0x319>
xor    %ecx,%ecx
jmp    1570 <verifica_somma+0x440>
cmp    $0x20,%ebp
jae    1455 <verifica_somma+0x325>
xor    %ecx,%ecx
jmp    1538 <verifica_somma+0x408>
mov    %r14d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
mov    %ebp,%ebx
cmp    $0x60,%rdi
jae    147b <verifica_somma+0x34b>
xor    %edi,%edi
jmp    14f0 <verifica_somma+0x3c0>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%r12,%rdi,1)
movups %xmm1,0x10(%r12,%rdi,1)
movups 0x20(%rax,%rdi,1),%xmm0
movups 0x30(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%r12,%rdi,1)
movups %xmm1,0x30(%r12,%rdi,1)
movups 0x40(%rax,%rdi,1),%xmm0
movups 0x50(%rax,%rdi,1),%xmm1
movups %xmm0,0x40(%r12,%rdi,1)
movups %xmm1,0x50(%r12,%rdi,1)
movups 0x60(%rax,%rdi,1),%xmm0
movups 0x70(%rax,%rdi,1),%xmm1
movups %xmm0,0x60(%r12,%rdi,1)
movups %xmm1,0x70(%r12,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1490 <verifica_somma+0x360>
test   %rdx,%rdx
je     152b <verifica_somma+0x3fb>
lea    (%r12,%rdi,1),%rsi
add    $0x10,%rsi
add    %rax,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1510 <verifica_somma+0x3e0>
cmp    %r14,%rcx
mov    %ebx,%ebp
je     1581 <verifica_somma+0x451>
test   $0x18,%r14b
je     1570 <verifica_somma+0x440>
mov    %rcx,%rdx
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdx,1),%rsi
mov    %rsi,(%r12,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1550 <verifica_somma+0x420>
cmp    %r14,%rcx
je     1581 <verifica_somma+0x451>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
mov    %dl,(%r12,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1570 <verifica_somma+0x440>
test   %ebp,%ebp
jle    1614 <verifica_somma+0x4e4>
mov    $0xfffffffe,%ecx
add    %r14,%rcx
add    $0xffffffffffffffff,%r14
jmp    15b5 <verifica_somma+0x485>
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rcx
lea    -0x1(%r14),%rax
add    $0x1,%r14
cmp    $0x1,%r14
mov    %rax,%r14
jbe    1614 <verifica_somma+0x4e4>
mov    %r14d,%eax
movsbl (%r8,%rax,1),%esi
movsbl 0x0(%r13,%rax,1),%edx
add    %esi,%edx
movsbl (%r15,%rax,1),%esi
lea    (%rsi,%rdx,1),%edi
add    $0xffffff70,%edi
imul   $0x6667,%edi,%ebp
mov    %ebp,%ebx
shr    $0x1f,%ebx
sar    $0x12,%ebp
add    %ebx,%ebp
add    %ebp,%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %ebp,%edi
movswl %di,%edi
movsbl (%r12,%rax,1),%ebp
add    $0xffffffd0,%ebp
xor    %eax,%eax
cmp    %edi,%ebp
jne    1639 <verifica_somma+0x509>
add    %esi,%edx
cmp    $0x9a,%edx
jl     15a0 <verifica_somma+0x470>
test   %r14d,%r14d
je     1639 <verifica_somma+0x509>
mov    %ecx,%eax
movb   $0x31,(%r8,%rax,1)
jmp    15a0 <verifica_somma+0x470>
mov    %r8,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @verifica_somma(i8** %0, i32 %1) {
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8**
store i8** %0, i8*** %4
store i32 %1, i32* %5
%10 = call i8* @malloc(i64 32)
%11 = bitcast i8* %10 to i8**
store i8** %11, i8*** %9
store i32 0, i32* %6
br label %12
12: ; preds = %24, %2
%13 = load i32, i32* %6
%14 = icmp slt i32 %13, 4
br i1 %14, label %15, label %27
15: ; preds = %12
%16 = load i32, i32* %5
%17 = sext i32 %16 to i64
%18 = mul i64 %17, 1
%19 = call i8* @malloc(i64 %18)
%20 = load i8**, i8*** %9
%21 = load i32, i32* %6
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8*, i8** %20, i64 %22
store i8* %19, i8** %23
br label %24
24: ; preds = %15
%25 = load i32, i32* %6
%26 = add nsw i32 %25, 1
store i32 %26, i32* %6
br label %12
27: ; preds = %12
store i32 0, i32* %6
br label %28
28: ; preds = %39, %27
%29 = load i32, i32* %6
%30 = load i32, i32* %5
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %42
32: ; preds = %28
%33 = load i8**, i8*** %9
%34 = getelementptr inbounds i8*, i8** %33, i64 0
%35 = load i8*, i8** %34
%36 = load i32, i32* %6
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
store i8 48, i8* %38
br label %39
39: ; preds = %32
%40 = load i32, i32* %6
%41 = add nsw i32 %40, 1
store i32 %41, i32* %6
br label %28
42: ; preds = %28
store i32 1, i32* %6
br label %43
43: ; preds = %73, %42
%44 = load i32, i32* %6
%45 = icmp slt i32 %44, 4
br i1 %45, label %46, label %76
46: ; preds = %43
store i32 0, i32* %7
br label %47
47: ; preds = %69, %46
%48 = load i32, i32* %7
%49 = load i32, i32* %5
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %72
51: ; preds = %47
%52 = load i8**, i8*** %4
%53 = load i32, i32* %6
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8*, i8** %52, i64 %54
%56 = load i8*, i8** %55
%57 = load i32, i32* %7
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %56, i64 %58
%60 = load i8, i8* %59
%61 = load i8**, i8*** %9
%62 = load i32, i32* %6
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8*, i8** %61, i64 %63
%65 = load i8*, i8** %64
%66 = load i32, i32* %7
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
store i8 %60, i8* %68
br label %69
69: ; preds = %51
%70 = load i32, i32* %7
%71 = add nsw i32 %70, 1
store i32 %71, i32* %7
br label %47
72: ; preds = %47
br label %73
73: ; preds = %72
%74 = load i32, i32* %6
%75 = add nsw i32 %74, 1
store i32 %75, i32* %6
br label %43
76: ; preds = %43
%77 = load i32, i32* %5
%78 = sub nsw i32 %77, 1
store i32 %78, i32* %6
br label %79
79: ; preds = %139, %76
%80 = load i32, i32* %6
%81 = icmp sge i32 %80, 0
br i1 %81, label %82, label %142
82: ; preds = %79
%83 = load i8**, i8*** %9
%84 = getelementptr inbounds i8*, i8** %83, i64 0
%85 = load i8*, i8** %84
%86 = load i32, i32* %6
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %85, i64 %87
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = load i8**, i8*** %9
%92 = getelementptr inbounds i8*, i8** %91, i64 1
%93 = load i8*, i8** %92
%94 = load i32, i32* %6
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
%99 = add nsw i32 %90, %98
%100 = load i8**, i8*** %9
%101 = getelementptr inbounds i8*, i8** %100, i64 2
%102 = load i8*, i8** %101
%103 = load i32, i32* %6
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %102, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = add nsw i32 %99, %107
%109 = sub nsw i32 %108, 144
store i32 %109, i32* %8
%110 = load i32, i32* %8
%111 = srem i32 %110, 10
%112 = load i8**, i8*** %9
%113 = getelementptr inbounds i8*, i8** %112, i64 3
%114 = load i8*, i8** %113
%115 = load i32, i32* %6
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %114, i64 %116
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = sub nsw i32 %119, 48
%121 = icmp ne i32 %111, %120
br i1 %121, label %122, label %123
122: ; preds = %82
store i32 0, i32* %3
br label %158
123: ; preds = %82
%124 = load i32, i32* %8
%125 = icmp sgt i32 %124, 9
br i1 %125, label %126, label %138
126: ; preds = %123
%127 = load i32, i32* %6
%128 = icmp eq i32 %127, 0
br i1 %128, label %129, label %130
129: ; preds = %126
store i32 0, i32* %3
br label %158
130: ; preds = %126
%131 = load i8**, i8*** %9
%132 = getelementptr inbounds i8*, i8** %131, i64 0
%133 = load i8*, i8** %132
%134 = load i32, i32* %6
%135 = sub nsw i32 %134, 1
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i8, i8* %133, i64 %136
store i8 49, i8* %137
br label %138
138: ; preds = %130, %123
br label %139
139: ; preds = %138
%140 = load i32, i32* %6
%141 = add nsw i32 %140, -1
store i32 %141, i32* %6
br label %79
142: ; preds = %79
store i32 0, i32* %6
br label %143
143: ; preds = %152, %142
%144 = load i32, i32* %6
%145 = icmp slt i32 %144, 4
br i1 %145, label %146, label %155
146: ; preds = %143
%147 = load i8**, i8*** %9
%148 = load i32, i32* %6
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8*, i8** %147, i64 %149
%151 = load i8*, i8** %150
br label %152
152: ; preds = %146
%153 = load i32, i32* %6
%154 = add nsw i32 %153, 1
store i32 %154, i32* %6
br label %143
155: ; preds = %143
%156 = load i8**, i8*** %9
%157 = bitcast i8** %156 to i8*
store i32 1, i32* %3
br label %158
158: ; preds = %155, %129, %122
%159 = load i32, i32* %3
ret i32 %159
}

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