#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 scanf(char *, char *, char *);
int strlen(char *);
int main() {
  char a[101], b[101], sum[105];
  int i, j, sz, sz1;
  int carry[100];
  int x, car;
  while (scanf("%s %s", a, b) == 2) {
    sz = strlen(a);
    sz1 = strlen(b);
    if ((sz == 1 && a[0] == '0') && (sz1 == 1 && b[0] == '0')) {
      break;
    } else if (sz >= sz1) {
      for (i = 0; i <= sz - sz1 - 1; i++) {
        sum[i] = '0';
      }
      i = 0;
      for (j = sz - sz1; j <= sz; j++) {
        sum[j] = b[i];
        i++;
      }
      sum[j] = '\0';
    } else if (sz1 > sz) {
      for (i = 0; i <= sz1 - sz - 1; i++) {
        sum[i] = '0';
      }
      i = 0;
      for (j = sz1 - sz; j <= sz1; j++) {
        sum[j] = a[i];
        i++;
      }
      sum[j] = '\0';
    }
    x = 0, car = 0;
    if (sz >= sz1) {
      for (i = sz - 1; i >= 0; i--) {
        carry[i] = a[i] - '0' + sum[i] - '0' + car;
        if (carry[i] > 9) {
          car = 1;
          x++;
        } else {
          car = 0;
        }
      }
    } else if (sz1 > sz) {
      for (i = sz1 - 1; i >= 0; i--) {
        carry[i] = b[i] - '0' + sum[i] - '0' + car;
        if (carry[i] > 9) {
          car = 1;
          x++;
        } else {
          car = 0;
        }
      }
    }
    if (x == 0) {
      printf("No carry operation.\n");
    } else if (x == 1) {
      printf("%d carry operation.\n", x);
    } else {
      printf("%d carry operations.\n", x);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x300,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x70(%rbp),%rsi
lea    -0xe0(%rbp),%rdx
lea    0xeac(%rip),%rdi
call   1050 <scanf@plt>
cmp    $0x2,%eax
jne    157b <main+0x44b>
lea    -0x70(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x15c(%rbp)
lea    -0xe0(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x160(%rbp)
cmpl   $0x1,-0x15c(%rbp)
jne    11bf <main+0x8f>
movsbl -0x70(%rbp),%eax
cmp    $0x30,%eax
jne    11bf <main+0x8f>
cmpl   $0x1,-0x160(%rbp)
jne    11bf <main+0x8f>
movsbl -0xe0(%rbp),%eax
cmp    $0x30,%eax
jne    11bf <main+0x8f>
jmp    157b <main+0x44b>
mov    -0x15c(%rbp),%eax
cmp    -0x160(%rbp),%eax
jl     129c <main+0x16c>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    -0x15c(%rbp),%ecx
sub    -0x160(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     121b <main+0xeb>
movslq -0x154(%rbp),%rax
movb   $0x30,-0x150(%rbp,%rax,1)
30
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    11db <main+0xab>
movl   $0x0,-0x154(%rbp)
mov    -0x15c(%rbp),%eax
sub    -0x160(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jg     1288 <main+0x158>
movslq -0x154(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1237 <main+0x107>
movslq -0x158(%rbp),%rax
movb   $0x0,-0x150(%rbp,%rax,1)
jmp    1376 <main+0x246>
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jle    1371 <main+0x241>
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    -0x160(%rbp),%ecx
sub    -0x15c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12f8 <main+0x1c8>
movslq -0x154(%rbp),%rax
movb   $0x30,-0x150(%rbp,%rax,1)
30
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    12b8 <main+0x188>
movl   $0x0,-0x154(%rbp)
mov    -0x160(%rbp),%eax
sub    -0x15c(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
cmp    -0x160(%rbp),%eax
jg     1362 <main+0x232>
movslq -0x154(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1314 <main+0x1e4>
movslq -0x158(%rbp),%rax
movb   $0x0,-0x150(%rbp,%rax,1)
jmp    1376 <main+0x246>
jmp    137b <main+0x24b>
movl   $0x0,-0x2f4(%rbp)
movl   $0x0,-0x2f8(%rbp)
mov    -0x15c(%rbp),%eax
cmp    -0x160(%rbp),%eax
jl     144f <main+0x31f>
mov    -0x15c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x154(%rbp)
cmpl   $0x0,-0x154(%rbp)
jl     144a <main+0x31a>
movslq -0x154(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%ecx
sub    $0x30,%ecx
movslq -0x154(%rbp),%rax
movsbl -0x150(%rbp,%rax,1),%eax
ff
add    %eax,%ecx
sub    $0x30,%ecx
add    -0x2f8(%rbp),%ecx
movslq -0x154(%rbp),%rax
mov    %ecx,-0x2f0(%rbp,%rax,4)
movslq -0x154(%rbp),%rax
cmpl   $0x9,-0x2f0(%rbp,%rax,4)
09
jle    1427 <main+0x2f7>
movl   $0x1,-0x2f8(%rbp)
mov    -0x2f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f4(%rbp)
jmp    1431 <main+0x301>
movl   $0x0,-0x2f8(%rbp)
jmp    1436 <main+0x306>
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
jmp    13b0 <main+0x280>
jmp    1517 <main+0x3e7>
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jle    1512 <main+0x3e2>
mov    -0x160(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x154(%rbp)
cmpl   $0x0,-0x154(%rbp)
jl     150d <main+0x3dd>
movslq -0x154(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%ecx
ff
sub    $0x30,%ecx
movslq -0x154(%rbp),%rax
movsbl -0x150(%rbp,%rax,1),%eax
ff
add    %eax,%ecx
sub    $0x30,%ecx
add    -0x2f8(%rbp),%ecx
movslq -0x154(%rbp),%rax
mov    %ecx,-0x2f0(%rbp,%rax,4)
movslq -0x154(%rbp),%rax
cmpl   $0x9,-0x2f0(%rbp,%rax,4)
09
jle    14ea <main+0x3ba>
movl   $0x1,-0x2f8(%rbp)
mov    -0x2f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f4(%rbp)
jmp    14f4 <main+0x3c4>
movl   $0x0,-0x2f8(%rbp)
jmp    14f9 <main+0x3c9>
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
jmp    1470 <main+0x340>
jmp    1512 <main+0x3e2>
jmp    1517 <main+0x3e7>
cmpl   $0x0,-0x2f4(%rbp)
jne    1537 <main+0x407>
lea    0xadb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1576 <main+0x446>
cmpl   $0x1,-0x2f4(%rbp)
jne    155d <main+0x42d>
mov    -0x2f4(%rbp),%esi
lea    0xaca(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1571 <main+0x441>
mov    -0x2f4(%rbp),%esi
lea    0xac6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1576 <main+0x446>
jmp    1142 <main+0x12>
xor    %eax,%eax
add    $0x300,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
lea    0xe88(%rip),%rdi
lea    0x70(%rsp),%rsi
lea    0xe0(%rsp),%rdx
call   1080 <scanf@plt>
cmp    $0x2,%eax
jne    1458 <main+0x2f8>
mov    $0xffffffff,%r15d
lea    0x70(%rsp),%r14
lea    0xe0(%rsp),%rbx
jmp    11df <main+0x7f>
nopl   0x0(%rax,%rax,1)
lea    0xe7a(%rip),%rdi
call   1030 <puts@plt>
lea    0xe3d(%rip),%rdi
mov    %r14,%rsi
lea    0xe0(%rsp),%rbx
mov    %rbx,%rdx
call   1080 <scanf@plt>
cmp    $0x2,%eax
jne    1458 <main+0x2f8>
mov    %r14,%rdi
call   1040 <strlen@plt>
mov    %eax,%ebp
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %eax,%r12d
cmp    $0x1,%ebp
jne    1214 <main+0xb4>
cmpb   $0x30,0x70(%rsp)
jne    1214 <main+0xb4>
cmp    $0x1,%r12d
jne    1214 <main+0xb4>
cmpb   $0x30,0xe0(%rsp)
30
je     1458 <main+0x2f8>
mov    %ebp,%r13d
sub    %r12d,%r13d
jge    1280 <main+0x120>
mov    %r12d,%r13d
sub    %ebp,%r13d
test   %r13d,%r13d
jle    123f <main+0xdf>
mov    %ebp,%edx
not    %edx
add    %r12d,%edx
add    $0x1,%rdx
mov    %rsp,%rdi
mov    $0x30,%esi
call   1060 <memset@plt>
test   %ebp,%ebp
js     12dd <main+0x17d>
movslq %r13d,%rbx
cmp    %r13d,%r12d
mov    %r13d,%edx
cmovg  %r12d,%edx
lea    (%rsp,%rbx,1),%rdi
add    %ebp,%edx
sub    %r12d,%edx
add    $0x1,%rdx
mov    %r14,%rsi
call   1070 <memcpy@plt>
movslq %r12d,%rax
add    $0xffffffffffffffff,%rbx
add    $0x1,%rbx
add    $0x1,%r13d
cmp    %rax,%rbx
jl     1270 <main+0x110>
jmp    12dd <main+0x17d>
nop
test   %r13d,%r13d
jle    129d <main+0x13d>
mov    %r12d,%edx
not    %edx
add    %ebp,%edx
add    $0x1,%rdx
mov    %rsp,%rdi
mov    $0x30,%esi
call   1060 <memset@plt>
test   %r12d,%r12d
js     12dd <main+0x17d>
movslq %r13d,%r14
cmp    %r13d,%ebp
mov    %r13d,%edx
cmovg  %ebp,%edx
lea    (%rsp,%r14,1),%rdi
add    %r12d,%edx
sub    %ebp,%edx
add    $0x1,%rdx
mov    %rbx,%rsi
call   1070 <memcpy@plt>
movslq %ebp,%rax
add    $0xffffffffffffffff,%r14
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
add    $0x1,%r13d
cmp    %rax,%r14
jl     12d0 <main+0x170>
movslq %r13d,%rax
movb   $0x0,(%rsp,%rax,1)
cmp    %r12d,%ebp
jge    1390 <main+0x230>
test   %r12d,%r12d
lea    0x70(%rsp),%r14
jle    11b0 <main+0x50>
mov    %r12d,%ecx
xor    %edx,%edx
mov    %rcx,%rax
mov    $0x0,%esi
cmp    $0x1,%r12d
je     136c <main+0x20c>
mov    %ecx,%edi
and    $0xfffffffe,%edi
xor    %edx,%edx
mov    %rcx,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rax,%r15,1),%ebp
movsbl 0xe0(%rsp,%rbp,1),%ebx
movsbl (%rsp,%rbp,1),%ebp
or     $0xffffffa0,%edx
add    %ebx,%edx
add    %ebp,%edx
xor    %ebp,%ebp
cmp    $0xa,%edx
setge  %bpl
add    %ebp,%esi
add    $0xfffffffffffffffe,%rax
mov    %eax,%edx
movsbl 0xe0(%rsp,%rdx,1),%ebx
movsbl (%rsp,%rdx,1),%edx
add    %ebp,%ebx
lea    (%rdx,%rbx,1),%ebp
add    $0xffffffa0,%ebp
xor    %edx,%edx
cmp    $0xa,%ebp
setge  %dl
add    %edx,%esi
add    $0xfffffffffffffffe,%rdi
jne    1320 <main+0x1c0>
test   $0x1,%cl
je     1428 <main+0x2c8>
add    %r15d,%eax
movsbl 0xe0(%rsp,%rax,1),%ecx
jmp    1413 <main+0x2b3>
cs nopw 0x0(%rax,%rax,1)
nop
test   %ebp,%ebp
lea    0x70(%rsp),%r14
jle    11b0 <main+0x50>
mov    %ebp,%ecx
xor    %edx,%edx
mov    %rcx,%rax
mov    $0x0,%esi
cmp    $0x1,%ebp
je     1406 <main+0x2a6>
mov    %ecx,%edi
and    $0xfffffffe,%edi
xor    %edx,%edx
mov    %rcx,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rax,%r15,1),%ebp
movsbl 0x70(%rsp,%rbp,1),%ebx
movsbl (%rsp,%rbp,1),%ebp
or     $0xffffffa0,%edx
add    %ebx,%edx
add    %ebp,%edx
xor    %ebp,%ebp
cmp    $0xa,%edx
setge  %bpl
add    %ebp,%esi
add    $0xfffffffffffffffe,%rax
mov    %eax,%edx
movsbl 0x70(%rsp,%rdx,1),%ebx
movsbl (%rsp,%rdx,1),%edx
add    %ebp,%ebx
lea    (%rdx,%rbx,1),%ebp
add    $0xffffffa0,%ebp
xor    %edx,%edx
cmp    $0xa,%ebp
setge  %dl
add    %edx,%esi
add    $0xfffffffffffffffe,%rdi
jne    13c0 <main+0x260>
test   $0x1,%cl
je     1428 <main+0x2c8>
add    %r15d,%eax
movsbl 0x70(%rsp,%rax,1),%ecx
add    %edx,%ecx
movsbl (%rsp,%rax,1),%eax
add    %ecx,%eax
add    $0xffffffa0,%eax
xor    %ecx,%ecx
cmp    $0xa,%eax
setge  %cl
add    %ecx,%esi
cmp    $0x1,%esi
je     1440 <main+0x2e0>
test   %esi,%esi
je     11b0 <main+0x50>
lea    0xbdf(%rip),%rdi
jmp    144c <main+0x2ec>
xchg   %ax,%ax
lea    0xbbf(%rip),%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    11bc <main+0x5c>
xor    %eax,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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