#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 *, char *);
int /*<<< orphan*/ scanf(char *, int *, int *);
int strlen(char *);
int main() {
  int A, B, Result, Div, Cont, Mod, Cont2;
  char ForaZero[12], SemZer[12];
  scanf("%d%d", &A, &B);
  while (B != 0 && A != 0) {
    Cont = 0;
    Result = A + B;
    while (Result != 0) {
      Mod = Result % 10;
      Result = Result / 10;
      Mod = Mod + 48;
      if (Mod != 48) {
        ForaZero[Cont] = Mod;
        Cont++;
      }
    }
    ForaZero[Cont] = '\0';
    Cont = strlen(ForaZero);
    SemZer[Cont] = '\0';
    Mod = Cont;
    Cont = Cont - 1;
    for (Cont2 = 0; Cont2 < Mod; Cont2++) {
      SemZer[Cont2] = ForaZero[Cont];
      Cont--;
    }
    printf("%s\n", SemZer);
    scanf("%d%d", &A, &B);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeba(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
call   1050 <scanf@plt>
xor    %eax,%eax
cmpl   $0x0,-0xc(%rbp)
mov    %al,-0x39(%rbp)
je     116c <main+0x3c>
cmpl   $0x0,-0x8(%rbp)
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    117c <main+0x4c>
jmp    1270 <main+0x140>
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     11e0 <main+0xb0>
mov    -0x10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x30,-0x1c(%rbp)
je     11db <main+0xab>
mov    -0x1c(%rbp),%eax
mov    %al,%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0x2c(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    118c <main+0x5c>
movslq -0x18(%rbp),%rax
movb   $0x0,-0x2c(%rbp,%rax,1)
lea    -0x2c(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
movslq -0x18(%rbp),%rax
movb   $0x0,-0x38(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1247 <main+0x117>
movslq -0x18(%rbp),%rax
mov    -0x2c(%rbp,%rax,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x38(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1214 <main+0xe4>
lea    -0x38(%rbp),%rsi
lea    0xdb3(%rip),%rdi
call   1040 <printf@plt>
lea    0xda2(%rip),%rdi
lea    -0x8(%rbp),%rsi
lea    -0xc(%rbp),%rdx
call   1050 <scanf@plt>
jmp    1153 <main+0x23>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
lea    0xebb(%rip),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
call   1050 <scanf@plt>
mov    0x8(%rsp),%edx
test   %edx,%edx
je     137b <main+0x24b>
mov    0xc(%rsp),%eax
test   %eax,%eax
je     137b <main+0x24b>
lea    0xf(%rsp),%rbx
lea    0xe8d(%rip),%r15
lea    0x1c(%rsp),%r12
lea    0xe7c(%rip),%r13
lea    0xc(%rsp),%r14
lea    0x8(%rsp),%rbp
xchg   %ax,%ax
mov    $0x0,%ecx
add    %edx,%eax
je     11e0 <main+0xb0>
xor    %ecx,%ecx
jmp    11aa <main+0x7a>
nopl   (%rax)
add    $0x9,%eax
cmp    $0x12,%eax
mov    %edx,%eax
jbe    11e0 <main+0xb0>
movslq %eax,%rsi
imul   $0x66666667,%rsi,%rdx
mov    %rdx,%rdi
shr    $0x3f,%rdi
sar    $0x22,%rdx
add    %edi,%edx
lea    (%rdx,%rdx,1),%edi
lea    (%rdi,%rdi,4),%edi
sub    %edi,%esi
je     11a0 <main+0x70>
add    $0x30,%sil
movslq %ecx,%rcx
mov    %sil,0x10(%rsp,%rcx,1)
add    $0x1,%ecx
jmp    11a0 <main+0x70>
nopl   0x0(%rax)
movslq %ecx,%rax
movb   $0x0,0x10(%rsp,%rax,1)
lea    0x10(%rsp),%rdi
call   1030 <strlen@plt>
movslq %eax,%rdx
movb   $0x0,0x1c(%rsp,%rdx,1)
test   %edx,%edx
jle    1344 <main+0x214>
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1220 <main+0xf0>
xor    %eax,%eax
mov    %rdx,%rsi
jmp    1328 <main+0x1f8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x20,%eax
jae    122c <main+0xfc>
xor    %eax,%eax
jmp    12d0 <main+0x1a0>
mov    %ecx,%eax
and    $0xffffffe0,%eax
lea    (%rsp),%rsi
add    %rdx,%rsi
xor    %edi,%edi
pxor   %xmm3,%xmm3
xchg   %ax,%ax
movdqu -0x10(%rsi),%xmm0
movdqu (%rsi),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm1,0x1c(%rsp,%rdi,1)
movdqu %xmm0,0x2c(%rsp,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%rax
jne    1240 <main+0x110>
cmp    %rcx,%rax
je     1344 <main+0x214>
test   $0x18,%cl
je     1373 <main+0x243>
mov    %rax,%rdi
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rdx,%rsi
sub    %rax,%rsi
sub    %rdi,%rdx
lea    0x8(%rsp),%rbx
add    %rbx,%rdx
pxor   %xmm1,%xmm1
nopl   (%rax)
movq   (%rdx),%xmm0
punpcklbw %xmm1,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0x1c(%rsp,%rdi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rdx
cmp    %rdi,%rax
jne    12f0 <main+0x1c0>
cmp    %rcx,%rax
lea    0xf(%rsp),%rbx
je     1344 <main+0x214>
add    %rbx,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
mov    %dl,0x1c(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
cmp    %rax,%rcx
jne    1330 <main+0x200>
mov    %r15,%rdi
mov    %r12,%rsi
call   1040 <printf@plt>
mov    %r13,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1050 <scanf@plt>
mov    0x8(%rsp),%edx
test   %edx,%edx
je     137b <main+0x24b>
mov    0xc(%rsp),%eax
test   %eax,%eax
jne    1190 <main+0x60>
jmp    137b <main+0x24b>
sub    %rax,%rdx
jmp    120b <main+0xdb>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"%d%d\00"
@.str.1 = [4 x i8] c"%s\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [12 x i8]
%10 = alloca [12 x i8]
store i32 0, i32* %1
%11 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %2, i32* %3)
br label %12
12: ; preds = %74, %0
%13 = load i32, i32* %3
%14 = icmp ne i32 %13, 0
br i1 %14, label %15, label %18
15: ; preds = %12
%16 = load i32, i32* %2
%17 = icmp ne i32 %16, 0
br label %18
18: ; preds = %15, %12
%19 = phi i1 [ false, %12 ], [ %17, %15 ]
br i1 %19, label %20, label %78
20: ; preds = %18
store i32 0, i32* %6
%21 = load i32, i32* %2
%22 = load i32, i32* %3
%23 = add nsw i32 %21, %22
store i32 %23, i32* %4
br label %24
24: ; preds = %44, %20
%25 = load i32, i32* %4
%26 = icmp ne i32 %25, 0
br i1 %26, label %27, label %45
27: ; preds = %24
%28 = load i32, i32* %4
%29 = srem i32 %28, 10
store i32 %29, i32* %7
%30 = load i32, i32* %4
%31 = sdiv i32 %30, 10
store i32 %31, i32* %4
%32 = load i32, i32* %7
%33 = add nsw i32 %32, 48
store i32 %33, i32* %7
%34 = load i32, i32* %7
%35 = icmp ne i32 %34, 48
br i1 %35, label %36, label %44
36: ; preds = %27
%37 = load i32, i32* %7
%38 = trunc i32 %37 to i8
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [12 x i8], [12 x i8]* %9, i64 0, i64 %40
store i8 %38, i8* %41
%42 = load i32, i32* %6
%43 = add nsw i32 %42, 1
store i32 %43, i32* %6
br label %44
44: ; preds = %36, %27
br label %24
45: ; preds = %24
%46 = load i32, i32* %6
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [12 x i8], [12 x i8]* %9, i64 0, i64 %47
store i8 0, i8* %48
%49 = getelementptr inbounds [12 x i8], [12 x i8]* %9, i64 0, i64 0
%50 = call i32 @strlen(i8* %49)
store i32 %50, i32* %6
%51 = load i32, i32* %6
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [12 x i8], [12 x i8]* %10, i64 0, i64 %52
store i8 0, i8* %53
%54 = load i32, i32* %6
store i32 %54, i32* %7
%55 = load i32, i32* %6
%56 = sub nsw i32 %55, 1
store i32 %56, i32* %6
store i32 0, i32* %8
br label %57
57: ; preds = %71, %45
%58 = load i32, i32* %8
%59 = load i32, i32* %7
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %74
61: ; preds = %57
%62 = load i32, i32* %6
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [12 x i8], [12 x i8]* %9, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = load i32, i32* %8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [12 x i8], [12 x i8]* %10, i64 0, i64 %67
store i8 %65, i8* %68
%69 = load i32, i32* %6
%70 = add nsw i32 %69, -1
store i32 %70, i32* %6
br label %71
71: ; preds = %61
%72 = load i32, i32* %8
%73 = add nsw i32 %72, 1
store i32 %73, i32* %8
br label %57
74: ; preds = %57
%75 = getelementptr inbounds [12 x i8], [12 x i8]* %10, i64 0, i64 0
%76 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8* %75)
%77 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %2, i32* %3)
br label %12
78: ; preds = %18
ret i32 0
}

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