#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*/ reverse(char *, char *);
int strlen(char *);
void call_mul(char *first, char *sec, char *result) {
  char F[1000], S[1000], Res[1000];
  int f_len, s_len, sum, carry, i, res, t_len, r, f, s;
  f_len = strlen(first);
  s_len = strlen(sec);
  reverse(first, F);
  reverse(sec, S);
  t_len = f_len + s_len;
  r = -1;
  for (f = 0; f <= t_len; f++)
    Res[f] = '0';
  Res[f] = '\0';
  for (s = 0; s < s_len; s++) {
    carry = 0;
    for (f = 0; f < f_len; f++) {
      res = (F[f] - '0') * (S[s] - '0') + carry + (Res[f + s] - '0');
      Res[f + s] = res % 10 + '0';
      carry = res / 10;
      if (f + s > r)
        r = f + s;
    }
    while (carry != 0) {
      res = carry + Res[f + s] - '0';
      carry = res / 10;
      Res[f + s] = res % 10 + '0';
      if (f + s > r)
        r = f + s;
      f++;
    }
  }
  Res[r + 1] = '\0';
  reverse(Res, result);
}


x86 assembly (clang, -O0):
<call_mul>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xbe4(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xbe8(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x400(%rbp),%rsi
call   1030 <reverse@plt>
mov    -0x10(%rbp),%rdi
lea    -0x7f0(%rbp),%rsi
call   1030 <reverse@plt>
mov    -0xbe4(%rbp),%eax
add    -0xbe8(%rbp),%eax
mov    %eax,-0xbfc(%rbp)
movl   $0xffffffff,-0xc00(%rbp)
ff ff ff
movl   $0x0,-0xc04(%rbp)
mov    -0xc04(%rbp),%eax
cmp    -0xbfc(%rbp),%eax
jg     11d0 <call_mul+0xb0>
movslq -0xc04(%rbp),%rax
movb   $0x30,-0xbe0(%rbp,%rax,1)
30
mov    -0xc04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc04(%rbp)
jmp    119b <call_mul+0x7b>
movslq -0xc04(%rbp),%rax
movb   $0x0,-0xbe0(%rbp,%rax,1)
movl   $0x0,-0xc08(%rbp)
mov    -0xc08(%rbp),%eax
cmp    -0xbe8(%rbp),%eax
jge    13bc <call_mul+0x29c>
movl   $0x0,-0xbf0(%rbp)
movl   $0x0,-0xc04(%rbp)
mov    -0xc04(%rbp),%eax
cmp    -0xbe4(%rbp),%eax
jge    12ef <call_mul+0x1cf>
movslq -0xc04(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
sub    $0x30,%eax
movslq -0xc08(%rbp),%rcx
movsbl -0x7f0(%rbp,%rcx,1),%ecx
ff
sub    $0x30,%ecx
imul   %ecx,%eax
add    -0xbf0(%rbp),%eax
mov    -0xc04(%rbp),%ecx
add    -0xc08(%rbp),%ecx
movslq %ecx,%rcx
movsbl -0xbe0(%rbp,%rcx,1),%ecx
ff
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0xbf8(%rbp)
mov    -0xbf8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
cltq
mov    %cl,-0xbe0(%rbp,%rax,1)
mov    -0xbf8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xbf0(%rbp)
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
cmp    -0xc00(%rbp),%eax
jle    12d6 <call_mul+0x1b6>
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
mov    %eax,-0xc00(%rbp)
jmp    12db <call_mul+0x1bb>
mov    -0xc04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc04(%rbp)
jmp    120f <call_mul+0xef>
jmp    12f4 <call_mul+0x1d4>
cmpl   $0x0,-0xbf0(%rbp)
je     13a3 <call_mul+0x283>
mov    -0xbf0(%rbp),%eax
mov    -0xc04(%rbp),%ecx
add    -0xc08(%rbp),%ecx
movslq %ecx,%rcx
movsbl -0xbe0(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
sub    $0x30,%eax
mov    %eax,-0xbf8(%rbp)
mov    -0xbf8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xbf0(%rbp)
mov    -0xbf8(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
cltq
mov    %cl,-0xbe0(%rbp,%rax,1)
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
cmp    -0xc00(%rbp),%eax
jle    138f <call_mul+0x26f>
mov    -0xc04(%rbp),%eax
add    -0xc08(%rbp),%eax
mov    %eax,-0xc00(%rbp)
mov    -0xc04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc04(%rbp)
jmp    12f4 <call_mul+0x1d4>
jmp    13a8 <call_mul+0x288>
mov    -0xc08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc08(%rbp)
jmp    11e9 <call_mul+0xc9>
mov    -0xc00(%rbp),%eax
add    $0x1,%eax
cltq
movb   $0x0,-0xbe0(%rbp,%rax,1)
lea    -0xbe0(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1030 <reverse@plt>
add    $0xc10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<call_mul>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xbc8,%rsp
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%rbx
call   1040 <strlen@plt>
mov    %eax,%r13d
mov    %r12,%rdi
call   1040 <strlen@plt>
mov    %eax,%r15d
lea    0x7e0(%rsp),%rsi
mov    %rbx,%rdi
call   1030 <reverse@plt>
lea    0x3f0(%rsp),%rsi
mov    %r12,%rdi
call   1030 <reverse@plt>
mov    %r15d,%ebx
add    %r13d,%ebx
js     119a <call_mul+0x6a>
add    $0x1,%ebx
mov    %rsp,%rdi
mov    $0x30,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
jmp    119c <call_mul+0x6c>
xor    %ebx,%ebx
movb   $0x0,(%rsp,%rbx,1)
test   %r15d,%r15d
jle    12a9 <call_mul+0x179>
mov    %r15d,%r8d
mov    %r13d,%r11d
mov    $0xffffffff,%eax
xor    %r10d,%r10d
mov    %r11,%r9
jmp    11d1 <call_mul+0xa1>
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x1,%r9
cmp    %r8,%r10
je     12ae <call_mul+0x17e>
test   %r13d,%r13d
jle    11c0 <call_mul+0x90>
movsbl 0x3f0(%rsp,%r10,1),%r15d
add    $0xffffffd0,%r15d
xor    %ecx,%ecx
mov    %r10,%rsi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsbl 0x7e0(%rsp,%rcx,1),%edi
add    $0xffffffd0,%edi
imul   %r15d,%edi
movsbl (%rsp,%rsi,1),%edx
add    %ebx,%edx
add    %edx,%edi
add    $0xffffffd0,%edi
movslq %edi,%rdx
imul   $0x66666667,%rdx,%rbx
mov    %rbx,%rbp
shr    $0x3f,%rbp
sar    $0x22,%rbx
add    %ebp,%ebx
lea    (%rbx,%rbx,1),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %ebp,%edx
add    $0x30,%dl
cltq
cmp    %rax,%rsi
cmovg  %esi,%eax
mov    %dl,(%rsp,%rsi,1)
add    $0x1,%rcx
add    $0x1,%rsi
cmp    %rcx,%r11
jne    11f0 <call_mul+0xc0>
add    $0x9,%edi
mov    %r9,%rcx
cmp    $0x13,%edi
jb     11c0 <call_mul+0x90>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl (%rsp,%rcx,1),%edx
lea    (%rbx,%rdx,1),%esi
add    $0xffffffd0,%esi
movslq %esi,%rsi
add    %ebx,%edx
add    $0xffffffd9,%edx
imul   $0x66666667,%rsi,%rbx
mov    %rbx,%rdi
shr    $0x3f,%rdi
sar    $0x22,%rbx
add    %edi,%ebx
lea    (%rbx,%rbx,1),%edi
lea    (%rdi,%rdi,4),%edi
sub    %edi,%esi
add    $0x30,%sil
mov    %sil,(%rsp,%rcx,1)
cmp    %ecx,%eax
cmovl  %ecx,%eax
add    $0x1,%rcx
cmp    $0x12,%edx
ja     1260 <call_mul+0x130>
jmp    11c0 <call_mul+0x90>
mov    $0xffffffff,%eax
cltq
mov    %rsp,%rdi
movb   $0x0,0x1(%rax,%rdi,1)
mov    %r14,%rsi
call   1030 <reverse@plt>
add    $0xbc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @call_mul(i8* %0, i8* %1, i8* %2) {
%4 = alloca [1000 x i8]
%5 = alloca [1000 x i8]
%6 = alloca [1000 x i8]
%7 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
%8 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 0
%9 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 0
%10 = tail call i32 @strlen(i8* %0)
%11 = tail call i32 @strlen(i8* %1)
%12 = call i32 @reverse(i8* %0, i8* %7)
%13 = call i32 @reverse(i8* %1, i8* %8)
%14 = add i32 %11, %10
%15 = icmp slt i32 %14, 0
br i1 %15, label %22, label %16
16: ; preds = %3
%17 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 0
%18 = add nuw i32 %14, 1
%19 = zext i32 %18 to i64
%20 = add nuw i32 %14, 1
%21 = zext i32 %20 to i64
br label %22
22: ; preds = %16, %3
%23 = phi i64 [ 0, %3 ], [ %21, %16 ]
%24 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %23
store i8 0, i8* %24
%25 = icmp sgt i32 %11, 0
br i1 %25, label %26, label %92
26: ; preds = %22
%27 = icmp sgt i32 %10, 0
%28 = zext i32 %11 to i64
%29 = zext i32 %10 to i64
%30 = zext i32 %10 to i64
br label %31
31: ; preds = %26, %88
%32 = phi i64 [ 0, %26 ], [ %90, %88 ]
%33 = phi i32 [ -1, %26 ], [ %89, %88 ]
br i1 %27, label %34, label %88
34: ; preds = %31
%35 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %32
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = add nsw i32 %37, -48
br label %42
39: ; preds = %42
%40 = add i32 %57, 9
%41 = icmp ult i32 %40, 19
br i1 %41, label %88, label %68
42: ; preds = %34, %42
%43 = phi i64 [ 0, %34 ], [ %66, %42 ]
%44 = phi i32 [ %33, %34 ], [ %65, %42 ]
%45 = phi i32 [ 0, %34 ], [ %61, %42 ]
%46 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %43
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = add nsw i32 %48, -48
%50 = mul nsw i32 %38, %49
%51 = add nuw nsw i64 %43, %32
%52 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %51
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = add nsw i32 %45, -48
%56 = add nsw i32 %55, %54
%57 = add nsw i32 %56, %50
%58 = srem i32 %57, 10
%59 = trunc i32 %58 to i8
%60 = add nsw i8 %59, 48
store i8 %60, i8* %52
%61 = sdiv i32 %57, 10
%62 = sext i32 %44 to i64
%63 = icmp sgt i64 %51, %62
%64 = trunc i64 %51 to i32
%65 = select i1 %63, i32 %64, i32 %44
%66 = add nuw nsw i64 %43, 1
%67 = icmp eq i64 %66, %29
br i1 %67, label %39, label %42
68: ; preds = %39, %68
%69 = phi i64 [ %85, %68 ], [ %30, %39 ]
%70 = phi i32 [ %84, %68 ], [ %65, %39 ]
%71 = phi i32 [ %78, %68 ], [ %61, %39 ]
%72 = add nuw nsw i64 %69, %32
%73 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = add nsw i32 %71, -48
%77 = add nsw i32 %76, %75
%78 = sdiv i32 %77, 10
%79 = srem i32 %77, 10
%80 = trunc i32 %79 to i8
%81 = add nsw i8 %80, 48
store i8 %81, i8* %73
%82 = trunc i64 %72 to i32
%83 = icmp slt i32 %70, %82
%84 = select i1 %83, i32 %82, i32 %70
%85 = add nuw i64 %69, 1
%86 = add nsw i32 %77, 9
%87 = icmp ult i32 %86, 19
br i1 %87, label %88, label %68
88: ; preds = %68, %31, %39
%89 = phi i32 [ %65, %39 ], [ %33, %31 ], [ %84, %68 ]
%90 = add nuw nsw i64 %32, 1
%91 = icmp eq i64 %90, %28
br i1 %91, label %92, label %31
92: ; preds = %88, %22
%93 = phi i32 [ -1, %22 ], [ %89, %88 ]
%94 = add nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %95
store i8 0, i8* %96
%97 = call i32 @reverse(i8* %9, i8* %2)
ret void
}