#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 *, ...);
int /*<<< orphan*/ scanf(char *, char **);
int main() {
  int a[255], b[255], sum[255];
  int ac = 0, bc = 0, sc = 0;
  int reminder = 0, i;
  char num1[255], num2[255], *pa, *pb;
  printf("Enter first number : ");
  scanf("%s", &num1);
  printf("\nEnter second number : ");
  scanf("%s", &num2);
  pa = num1;
  pb = num2;
  while (*pa) {
    a[ac++] = *pa++ - 48;
  }
  while (*pb) {
    b[bc++] = *pb++ - 48;
  }
  if (ac < bc) {
    for (i = ac; i > 0; i--) {
      sum[sc++] = ((a[i - 1] + b[--bc]) + reminder) % 10;
      reminder = ((a[i - 1] + b[bc]) + reminder) / 10;
    }
    while (bc > 0) {
      sum[sc++] = b[--bc] + reminder;
      reminder = 0;
    }
  } else {
    for (i = bc; i > 0; i--) {
      sum[sc++] = ((b[i - 1] + a[--ac]) + reminder) % 10;
      reminder = ((b[i - 1] + a[ac]) + reminder) / 10;
    }
    if (ac == 0 && reminder == 1)
      sum[sc++] = reminder;
    while (ac > 0) {
      sum[sc++] = a[--ac] + reminder;
      reminder = 0;
    }
  }
  printf("Sum of both number is : ");
  for (i = sc - 1; i >= 0; i--) {
    printf("%d", sum[i]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe30,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xc04(%rbp)
movl   $0x0,-0xc08(%rbp)
movl   $0x0,-0xc0c(%rbp)
movl   $0x0,-0xc10(%rbp)
lea    0xe9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0xd20(%rbp),%rsi
lea    0xea0(%rip),%rdi
call   1040 <scanf@plt>
lea    0xe97(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0xe20(%rbp),%rsi
lea    0xe7f(%rip),%rdi
call   1040 <scanf@plt>
lea    -0xd20(%rbp),%rax
mov    %rax,-0xe28(%rbp)
lea    -0xe20(%rbp),%rax
mov    %rax,-0xe30(%rbp)
mov    -0xe28(%rbp),%rax
cmpb   $0x0,(%rax)
je     1202 <main+0xe2>
mov    -0xe28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0xe28(%rbp)
movsbl (%rax),%ecx
sub    $0x30,%ecx
mov    -0xc04(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc04(%rbp)
cltq
mov    %ecx,-0x400(%rbp,%rax,4)
jmp    11b8 <main+0x98>
jmp    1207 <main+0xe7>
mov    -0xe30(%rbp),%rax
cmpb   $0x0,(%rax)
je     1251 <main+0x131>
mov    -0xe30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0xe30(%rbp)
movsbl (%rax),%ecx
sub    $0x30,%ecx
mov    -0xc08(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc08(%rbp)
cltq
mov    %ecx,-0x800(%rbp,%rax,4)
jmp    1207 <main+0xe7>
mov    -0xc04(%rbp),%eax
cmp    -0xc08(%rbp),%eax
jge    1375 <main+0x255>
mov    -0xc04(%rbp),%eax
mov    %eax,-0xc14(%rbp)
cmpl   $0x0,-0xc14(%rbp)
jle    1317 <main+0x1f7>
mov    -0xc14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x400(%rbp,%rax,4),%eax
mov    -0xc08(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc08(%rbp)
movslq %ecx,%rcx
add    -0x800(%rbp,%rcx,4),%eax
add    -0xc10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0xc0c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc0c(%rbp)
cltq
mov    %edx,-0xc00(%rbp,%rax,4)
mov    -0xc14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x400(%rbp,%rax,4),%eax
movslq -0xc08(%rbp),%rcx
add    -0x800(%rbp,%rcx,4),%eax
add    -0xc10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc10(%rbp)
mov    -0xc14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc14(%rbp)
jmp    126f <main+0x14f>
jmp    131c <main+0x1fc>
cmpl   $0x0,-0xc08(%rbp)
jle    1370 <main+0x250>
mov    -0xc08(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc08(%rbp)
cltq
mov    -0x800(%rbp,%rax,4),%ecx
add    -0xc10(%rbp),%ecx
mov    -0xc0c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc0c(%rbp)
cltq
mov    %ecx,-0xc00(%rbp,%rax,4)
movl   $0x0,-0xc10(%rbp)
jmp    131c <main+0x1fc>
jmp    14c1 <main+0x3a1>
mov    -0xc08(%rbp),%eax
mov    %eax,-0xc14(%rbp)
cmpl   $0x0,-0xc14(%rbp)
jle    1429 <main+0x309>
mov    -0xc14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x800(%rbp,%rax,4),%eax
mov    -0xc04(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xc04(%rbp)
movslq %ecx,%rcx
add    -0x400(%rbp,%rcx,4),%eax
add    -0xc10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0xc0c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc0c(%rbp)
cltq
mov    %edx,-0xc00(%rbp,%rax,4)
mov    -0xc14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x800(%rbp,%rax,4),%eax
movslq -0xc04(%rbp),%rcx
add    -0x400(%rbp,%rcx,4),%eax
add    -0xc10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc10(%rbp)
mov    -0xc14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc14(%rbp)
jmp    1381 <main+0x261>
cmpl   $0x0,-0xc04(%rbp)
jne    1463 <main+0x343>
cmpl   $0x1,-0xc10(%rbp)
jne    1463 <main+0x343>
mov    -0xc10(%rbp),%ecx
mov    -0xc0c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc0c(%rbp)
cltq
mov    %ecx,-0xc00(%rbp,%rax,4)
jmp    1468 <main+0x348>
cmpl   $0x0,-0xc04(%rbp)
jle    14bc <main+0x39c>
mov    -0xc04(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc04(%rbp)
cltq
mov    -0x400(%rbp,%rax,4),%ecx
add    -0xc10(%rbp),%ecx
mov    -0xc0c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc0c(%rbp)
cltq
mov    %ecx,-0xc00(%rbp,%rax,4)
movl   $0x0,-0xc10(%rbp)
jmp    1468 <main+0x348>
jmp    14c1 <main+0x3a1>
lea    0xb69(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc0c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc14(%rbp)
cmpl   $0x0,-0xc14(%rbp)
jl     151b <main+0x3fb>
movslq -0xc14(%rbp),%rax
mov    -0xc00(%rbp,%rax,4),%esi
lea    0xb4a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc14(%rbp)
jmp    14de <main+0x3be>
xor    %eax,%eax
add    $0xe30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0xe00,%rsp
lea    0xecd(%rip),%rdi
xor    %r15d,%r15d
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xed2(%rip),%r14
lea    0x400(%rsp),%rsi
mov    %r14,%rdi
call   1040 <scanf@plt>
lea    0xebe(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xd00(%rsp),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
mov    0x400(%rsp),%al
mov    $0x0,%r14d
test   %al,%al
je     11af <main+0x8f>
xor    %r14d,%r14d
nopl   0x0(%rax)
movsbl %al,%eax
add    $0xffffffd0,%eax
mov    %eax,0x900(%rsp,%r14,4)
movzbl 0x401(%rsp,%r14,1),%eax
add    $0x1,%r14
test   %al,%al
jne    1190 <main+0x70>
mov    0xd00(%rsp),%cl
test   %cl,%cl
je     1361 <main+0x241>
mov    $0x1,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,%edx
movsbl %cl,%ecx
add    $0xffffffd0,%ecx
mov    %ecx,0x500(%rsp,%rax,4)
add    $0x1,%rax
movzbl 0x1(%rbx),%ecx
add    $0x1,%rbx
lea    0x1(%rdx),%esi
test   %cl,%cl
jne    11d0 <main+0xb0>
cmp    %eax,%r14d
jae    126d <main+0x14d>
test   %r14d,%r14d
jle    12fc <main+0x1dc>
mov    %r14d,%r9d
movslq %eax,%rcx
lea    (%rsp,%rcx,4),%r8
add    $0x500,%r8
xor    %ebx,%ebx
mov    $0xffffffffffffffff,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
lea    (%r9,%rdi,1),%esi
add    0x900(%rsp,%rsi,4),%ecx
add    (%r8,%rdi,4),%ecx
movslq %ecx,%rsi
imul   $0x66666667,%rsi,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,1),%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%esi
mov    %esi,(%rsp,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdi
cmp    %rbx,%r9
jne    1220 <main+0x100>
sub    %ebx,%eax
test   %eax,%eax
jg     1309 <main+0x1e9>
jmp    13be <main+0x29e>
test   %eax,%eax
jle    135e <main+0x23e>
movslq %r14d,%rcx
lea    (%rsp,%rcx,4),%r9
add    $0x8fc,%r9
mov    %edx,%r8d
lea    -0x1(%r8),%rsi
xor    %edi,%edi
xor    %r15d,%r15d
nop
mov    %esi,%ebx
add    0x500(%rsp,%rbx,4),%r15d
mov    %r15d,%ebx
add    (%r9),%ebx
movslq %ebx,%rdx
imul   $0x66666667,%rdx,%r15
mov    %r15,%rcx
shr    $0x3f,%rcx
sar    $0x22,%r15
add    %ecx,%r15d
lea    (%r15,%r15,1),%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%edx
mov    %edx,(%rsp,%rdi,4)
add    $0x1,%rdi
add    $0xfffffffffffffffc,%r9
add    $0xffffffffffffffff,%rsi
cmp    %rdi,%r8
jne    1290 <main+0x170>
cmp    %edi,%r14d
jne    1409 <main+0x2e9>
add    $0xfffffff6,%ebx
cmp    $0xa,%ebx
jae    1409 <main+0x2e9>
lea    0x1(%rax),%r14d
mov    %eax,%eax
movl   $0x1,(%rsp,%rax,4)
jmp    13be <main+0x29e>
xor    %r14d,%r14d
xor    %ecx,%ecx
test   %eax,%eax
jle    13be <main+0x29e>
mov    %eax,%edx
add    0x4fc(%rsp,%rdx,4),%ecx
mov    %r14d,%ebx
lea    0x1(%rbx),%r14
mov    %ecx,(%rsp,%rbx,4)
cmp    $0x1,%eax
je     13be <main+0x29e>
lea    -0x1(%rdx),%rcx
cmp    $0x8,%rcx
jae    1523 <main+0x403>
add    $0x1,%rcx
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rcx),%eax
mov    0x500(%rsp,%rax,4),%eax
mov    %eax,(%rsp,%r14,4)
add    $0x1,%r14
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     1340 <main+0x220>
jmp    13be <main+0x29e>
xor    %r15d,%r15d
xor    %eax,%eax
test   %r14d,%r14d
jle    13bb <main+0x29b>
mov    %r14d,%r11d
add    0x8fc(%rsp,%r11,4),%r15d
movslq %eax,%rdx
lea    0x1(%rdx),%rax
mov    %r15d,(%rsp,%rdx,4)
cmp    $0x1,%r14d
je     13bb <main+0x29b>
lea    -0x1(%r11),%rcx
cmp    $0x8,%rcx
jae    141a <main+0x2fa>
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
lea    -0x2(%rcx),%edx
mov    0x900(%rsp,%rdx,4),%edx
mov    %edx,(%rsp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     13a0 <main+0x280>
mov    %eax,%r14d
lea    0xc6c(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
test   %r14d,%r14d
jle    13fa <main+0x2da>
mov    %r14d,%ebx
add    $0x1,%rbx
lea    0xc6b(%rip),%r14
nop
lea    -0x2(%rbx),%eax
mov    (%rsp,%rax,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1030 <printf@plt>
add    $0xffffffffffffffff,%rbx
cmp    $0x1,%rbx
ja     13e0 <main+0x2c0>
xor    %eax,%eax
add    $0xe00,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
mov    %r14d,%r14d
sub    %rdi,%r14
test   %r14d,%r14d
jg     1368 <main+0x248>
jmp    13bb <main+0x29b>
lea    -0x2(%r11),%rsi
add    $0xfffffffe,%r14d
cmp    %esi,%r14d
jb     1392 <main+0x272>
mov    %rsi,%rdi
shr    $0x20,%rdi
jne    1392 <main+0x272>
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdi
mov    %rdi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     15eb <main+0x4cb>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsp,%rdx,4),%r10
add    $0x34,%r10
mov    $0xfffffff6,%edx
add    %rdx,%r11
xor    %edx,%edx
mov    %esi,%edi
movdqu 0x8e4(%rsp,%rdi,4),%xmm0
movdqu 0x8f4(%rsp,%rdi,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%r10,%rdx,4)
movdqu %xmm0,-0x20(%r10,%rdx,4)
mov    %r11d,%edi
movdqu 0x8e4(%rsp,%rdi,4),%xmm0
movdqu 0x8f4(%rsp,%rdi,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%r10,%rdx,4)
movdqu %xmm0,(%r10,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffff0,%r11
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rbx
jne    1470 <main+0x350>
test   $0x1,%r9b
je     150f <main+0x3ef>
lea    (%rax,%rdx,1),%rsi
not    %edx
add    %ecx,%edx
movdqu 0x8e4(%rsp,%rdx,4),%xmm0
movdqu 0x8f4(%rsp,%rdx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rsp,%rsi,4)
movdqu %xmm0,0x10(%rsp,%rsi,4)
add    %r8,%rax
cmp    %r8,%rcx
je     13bb <main+0x29b>
and    $0x7,%ecx
jmp    1392 <main+0x272>
lea    -0x2(%rdx),%rsi
add    $0xfffffffe,%eax
cmp    %esi,%eax
jb     1333 <main+0x213>
mov    %rsi,%rax
shr    $0x20,%rax
jne    1333 <main+0x213>
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     15fc <main+0x4dc>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rsp,%rbx,4),%r10
add    $0x34,%r10
mov    $0xfffffff6,%ebx
add    %rbx,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %esi,%eax
movdqu 0x4e4(%rsp,%rax,4),%xmm0
movdqu 0x4f4(%rsp,%rax,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%r10,%rbx,4)
movdqu %xmm0,-0x20(%r10,%rbx,4)
mov    %edx,%eax
movdqu 0x4e4(%rsp,%rax,4),%xmm0
movdqu 0x4f4(%rsp,%rax,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%r10,%rbx,4)
movdqu %xmm0,(%r10,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1580 <main+0x460>
jmp    15fe <main+0x4de>
xor    %edx,%edx
test   $0x1,%r9b
jne    14e0 <main+0x3c0>
jmp    150f <main+0x3ef>
xor    %ebx,%ebx
test   $0x1,%r9b
je     1633 <main+0x513>
lea    (%r14,%rbx,1),%rax
not    %ebx
add    %ecx,%ebx
movdqu 0x4e4(%rsp,%rbx,4),%xmm0
movdqu 0x4f4(%rsp,%rbx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rsp,%rax,4)
movdqu %xmm0,0x10(%rsp,%rax,4)
add    %r8,%r14
cmp    %r8,%rcx
je     13be <main+0x29e>
and    $0x7,%ecx
jmp    1333 <main+0x213>

LLVM IR (-O0):
@.str = [22 x i8] c"Enter first number : \00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [24 x i8] c"\0AEnter second number : \00"
@.str.3 = [25 x i8] c"Sum of both number is : \00"
@.str.4 = [3 x i8] c"%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [255 x i32]
%3 = alloca [255 x i32]
%4 = alloca [255 x i32]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [255 x i8]
%11 = alloca [255 x i8]
%12 = alloca i8*
%13 = alloca i8*
store i32 0, i32* %1
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
%14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
%15 = bitcast [255 x i8]* %10 to i8**
%16 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8** %15)
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
%18 = bitcast [255 x i8]* %11 to i8**
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8** %18)
%20 = getelementptr inbounds [255 x i8], [255 x i8]* %10, i64 0, i64 0
store i8* %20, i8** %12
%21 = getelementptr inbounds [255 x i8], [255 x i8]* %11, i64 0, i64 0
store i8* %21, i8** %13
br label %22
22: ; preds = %26, %0
%23 = load i8*, i8** %12
%24 = load i8, i8* %23
%25 = icmp ne i8 %24, 0
br i1 %25, label %26, label %36
26: ; preds = %22
%27 = load i8*, i8** %12
%28 = getelementptr inbounds i8, i8* %27, i32 1
store i8* %28, i8** %12
%29 = load i8, i8* %27
%30 = sext i8 %29 to i32
%31 = sub nsw i32 %30, 48
%32 = load i32, i32* %5
%33 = add nsw i32 %32, 1
store i32 %33, i32* %5
%34 = sext i32 %32 to i64
%35 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %34
store i32 %31, i32* %35
br label %22
36: ; preds = %22
br label %37
37: ; preds = %41, %36
%38 = load i8*, i8** %13
%39 = load i8, i8* %38
%40 = icmp ne i8 %39, 0
br i1 %40, label %41, label %51
41: ; preds = %37
%42 = load i8*, i8** %13
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %13
%44 = load i8, i8* %42
%45 = sext i8 %44 to i32
%46 = sub nsw i32 %45, 48
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
%49 = sext i32 %47 to i64
%50 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %49
store i32 %46, i32* %50
br label %37
51: ; preds = %37
%52 = load i32, i32* %5
%53 = load i32, i32* %6
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %112
55: ; preds = %51
%56 = load i32, i32* %5
store i32 %56, i32* %9
br label %57
57: ; preds = %92, %55
%58 = load i32, i32* %9
%59 = icmp sgt i32 %58, 0
br i1 %59, label %60, label %95
60: ; preds = %57
%61 = load i32, i32* %9
%62 = sub nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %63
%65 = load i32, i32* %64
%66 = load i32, i32* %6
%67 = add nsw i32 %66, -1
store i32 %67, i32* %6
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %68
%70 = load i32, i32* %69
%71 = add nsw i32 %65, %70
%72 = load i32, i32* %8
%73 = add nsw i32 %71, %72
%74 = srem i32 %73, 10
%75 = load i32, i32* %7
%76 = add nsw i32 %75, 1
store i32 %76, i32* %7
%77 = sext i32 %75 to i64
%78 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %77
store i32 %74, i32* %78
%79 = load i32, i32* %9
%80 = sub nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = load i32, i32* %6
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = add nsw i32 %83, %87
%89 = load i32, i32* %8
%90 = add nsw i32 %88, %89
%91 = sdiv i32 %90, 10
store i32 %91, i32* %8
br label %92
92: ; preds = %60
%93 = load i32, i32* %9
%94 = add nsw i32 %93, -1
store i32 %94, i32* %9
br label %57
95: ; preds = %57
br label %96
96: ; preds = %99, %95
%97 = load i32, i32* %6
%98 = icmp sgt i32 %97, 0
br i1 %98, label %99, label %111
99: ; preds = %96
%100 = load i32, i32* %6
%101 = add nsw i32 %100, -1
store i32 %101, i32* %6
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = load i32, i32* %8
%106 = add nsw i32 %104, %105
%107 = load i32, i32* %7
%108 = add nsw i32 %107, 1
store i32 %108, i32* %7
%109 = sext i32 %107 to i64
%110 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %109
store i32 %106, i32* %110
store i32 0, i32* %8
br label %96
111: ; preds = %96
br label %181
112: ; preds = %51
%113 = load i32, i32* %6
store i32 %113, i32* %9
br label %114
114: ; preds = %149, %112
%115 = load i32, i32* %9
%116 = icmp sgt i32 %115, 0
br i1 %116, label %117, label %152
117: ; preds = %114
%118 = load i32, i32* %9
%119 = sub nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = load i32, i32* %5
%124 = add nsw i32 %123, -1
store i32 %124, i32* %5
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %125
%127 = load i32, i32* %126
%128 = add nsw i32 %122, %127
%129 = load i32, i32* %8
%130 = add nsw i32 %128, %129
%131 = srem i32 %130, 10
%132 = load i32, i32* %7
%133 = add nsw i32 %132, 1
store i32 %133, i32* %7
%134 = sext i32 %132 to i64
%135 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %134
store i32 %131, i32* %135
%136 = load i32, i32* %9
%137 = sub nsw i32 %136, 1
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [255 x i32], [255 x i32]* %3, i64 0, i64 %138
%140 = load i32, i32* %139
%141 = load i32, i32* %5
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %142
%144 = load i32, i32* %143
%145 = add nsw i32 %140, %144
%146 = load i32, i32* %8
%147 = add nsw i32 %145, %146
%148 = sdiv i32 %147, 10
store i32 %148, i32* %8
br label %149
149: ; preds = %117
%150 = load i32, i32* %9
%151 = add nsw i32 %150, -1
store i32 %151, i32* %9
br label %114
152: ; preds = %114
%153 = load i32, i32* %5
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %164
155: ; preds = %152
%156 = load i32, i32* %8
%157 = icmp eq i32 %156, 1
br i1 %157, label %158, label %164
158: ; preds = %155
%159 = load i32, i32* %8
%160 = load i32, i32* %7
%161 = add nsw i32 %160, 1
store i32 %161, i32* %7
%162 = sext i32 %160 to i64
%163 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %162
store i32 %159, i32* %163
br label %164
164: ; preds = %158, %155, %152
br label %165
165: ; preds = %168, %164
%166 = load i32, i32* %5
%167 = icmp sgt i32 %166, 0
br i1 %167, label %168, label %180
168: ; preds = %165
%169 = load i32, i32* %5
%170 = add nsw i32 %169, -1
store i32 %170, i32* %5
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [255 x i32], [255 x i32]* %2, i64 0, i64 %171
%173 = load i32, i32* %172
%174 = load i32, i32* %8
%175 = add nsw i32 %173, %174
%176 = load i32, i32* %7
%177 = add nsw i32 %176, 1
store i32 %177, i32* %7
%178 = sext i32 %176 to i64
%179 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %178
store i32 %175, i32* %179
store i32 0, i32* %8
br label %165
180: ; preds = %165
br label %181
181: ; preds = %180, %111
%182 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
%183 = load i32, i32* %7
%184 = sub nsw i32 %183, 1
store i32 %184, i32* %9
br label %185
185: ; preds = %194, %181
%186 = load i32, i32* %9
%187 = icmp sge i32 %186, 0
br i1 %187, label %188, label %197
188: ; preds = %185
%189 = load i32, i32* %9
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [255 x i32], [255 x i32]* %4, i64 0, i64 %190
%192 = load i32, i32* %191
%193 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32 %192)
br label %194
194: ; preds = %188
%195 = load i32, i32* %9
%196 = add nsw i32 %195, -1
store i32 %196, i32* %9
br label %185
197: ; preds = %185
ret i32 0
}

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