#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 strlen(char *);
void add_0(char *str, int l) {
  int i, j, len = strlen(str);
  for (i = l - len, j = len; j >= 0; j--)
    str[j + i] = str[j];
  for (j = 0; i; i--, j++)
    str[j] = '0';
}


x86 assembly (clang, -O0):
<add_0>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     116d <add_0+0x5d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    113a <add_0+0x2a>
movl   $0x0,-0x14(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     11a1 <add_0+0x91>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1174 <add_0+0x64>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<add_0>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r14d
mov    %rdi,%r15
call   1030 <strlen@plt>
mov    %r14d,%r10d
sub    %eax,%r10d
test   %eax,%eax
js     120a <add_0+0xea>
mov    %eax,%r12d
cmp    $0x3,%eax
jae    1237 <add_0+0x117>
mov    %r12,%rdi
lea    0x1(%rdi),%ecx
mov    %r10d,%r9d
mov    %rdi,%rsi
and    $0x3,%rcx
je     118a <add_0+0x6a>
mov    %rdi,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r15,%rsi,1),%edx
lea    (%r9,%rsi,1),%ebp
movslq %ebp,%rbp
mov    %dl,(%r15,%rbp,1)
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffff,%rcx
jne    1170 <add_0+0x50>
cmp    $0x3,%rdi
jb     120a <add_0+0xea>
lea    -0x3(%rsi),%r8
lea    -0x2(%r10),%ecx
mov    %eax,%edi
not    %edi
add    %r14d,%edi
mov    $0xffffffffffffffff,%rbx
mov    %r15,%rdx
nopl   0x0(%rax)
movzbl (%rdx,%rsi,1),%r11d
lea    (%rsi,%r9,1),%ebp
movslq %ebp,%rbp
mov    %r11b,(%r15,%rbp,1)
movzbl -0x1(%rdx,%rsi,1),%r11d
lea    (%rdi,%rsi,1),%ebp
movslq %ebp,%rbp
mov    %r11b,(%r15,%rbp,1)
movzbl -0x2(%rdx,%rsi,1),%r11d
lea    (%rcx,%rsi,1),%ebp
movslq %ebp,%rbp
mov    %r11b,(%r15,%rbp,1)
movzbl -0x3(%rdx,%rsi,1),%r11d
lea    (%r8,%r9,1),%ebp
movslq %ebp,%rbp
mov    %r11b,(%r15,%rbp,1)
add    $0x4,%rbx
add    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%r9
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffc,%rdi
cmp    %rbx,%rsi
jne    11b0 <add_0+0x90>
test   %r10d,%r10d
je     1228 <add_0+0x108>
not    %eax
add    %r14d,%eax
add    $0x1,%rax
mov    %r15,%rdi
mov    $0x30,%esi
mov    %rax,%rdx
call   1040 <memset@plt>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %r14d,%r10d
jg     1150 <add_0+0x30>
movslq %r14d,%rcx
lea    (%r15,%rcx,1),%rdx
mov    %rdx,%rsi
sub    %r12,%rsi
cmp    %rdx,%rsi
ja     1150 <add_0+0x30>
lea    (%r15,%r12,1),%rdx
cmp    %r15,%rdx
jb     1150 <add_0+0x30>
mov    %rcx,%rdx
sub    %r12,%rdx
add    %r15,%rdx
lea    (%r12,%r15,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rdx
jae    1289 <add_0+0x169>
add    %r15,%rcx
add    $0x1,%rcx
cmp    %r15,%rcx
ja     1150 <add_0+0x30>
lea    0x1(%r12),%r13
movabs $0x1fffffff0,%r9
cmp    $0xf,%eax
jae    12a5 <add_0+0x185>
xor    %r8d,%r8d
jmp    1347 <add_0+0x227>
mov    %r13,%r8
and    %r9,%r8
lea    -0x10(%r8),%rcx
mov    %rcx,%r11
shr    $0x4,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1314 <add_0+0x1f4>
mov    %r13,%rsi
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%r12,%r15,1),%rbx
add    $0xfffffffffffffff1,%rbx
lea    -0x10(%r14),%r13d
mov    %r14d,%edx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rdi,1),%xmm0
lea    (%rdx,%rdi,1),%ebp
movslq %ebp,%rbp
movups %xmm0,-0xf(%r15,%rbp,1)
movups -0x10(%rbx,%rdi,1),%xmm0
lea    (%rdi,%r13,1),%ebp
movslq %ebp,%rbp
movups %xmm0,-0xf(%r15,%rbp,1)
add    $0xffffffffffffffe0,%rdi
add    $0xfffffffffffffffe,%rcx
jne    12e0 <add_0+0x1c0>
neg    %rdi
mov    %rsi,%r13
jmp    1316 <add_0+0x1f6>
xor    %edi,%edi
test   $0x1,%r11b
je     1338 <add_0+0x218>
mov    %r12,%rcx
sub    %rdi,%rcx
mov    %eax,%edx
sub    %edi,%edx
movups -0xf(%r15,%rcx,1),%xmm0
add    %r10d,%edx
movslq %edx,%rcx
movups %xmm0,-0xf(%r15,%rcx,1)
cmp    %r8,%r13
je     120a <add_0+0xea>
test   $0xc,%r13b
je     1395 <add_0+0x275>
add    $0xc,%r9
and    %r13,%r9
mov    %r12,%rdi
sub    %r9,%rdi
mov    %r14d,%ecx
sub    %r8d,%ecx
sub    %r8,%r12
sub    %r9,%r8
lea    (%r12,%r15,1),%rdx
add    $0xfffffffffffffffd,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%rdx,%rbx,1),%ebp
lea    (%rcx,%rbx,1),%esi
movslq %esi,%rsi
mov    %ebp,-0x3(%r15,%rsi,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%r8
jne    1370 <add_0+0x250>
cmp    %r9,%r13
jne    1153 <add_0+0x33>
jmp    120a <add_0+0xea>
sub    %r8,%r12
jmp    1150 <add_0+0x30>

LLVM IR (-O0):
define void @add_0(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
%8 = load i8*, i8** %3
%9 = call i32 @strlen(i8* %8)
store i32 %9, i32* %7
%10 = load i32, i32* %4
%11 = load i32, i32* %7
%12 = sub nsw i32 %10, %11
store i32 %12, i32* %5
%13 = load i32, i32* %7
store i32 %13, i32* %6
br label %14
14: ; preds = %29, %2
%15 = load i32, i32* %6
%16 = icmp sge i32 %15, 0
br i1 %16, label %17, label %32
17: ; preds = %14
%18 = load i8*, i8** %3
%19 = load i32, i32* %6
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i8, i8* %18, i64 %20
%22 = load i8, i8* %21
%23 = load i8*, i8** %3
%24 = load i32, i32* %6
%25 = load i32, i32* %5
%26 = add nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %23, i64 %27
store i8 %22, i8* %28
br label %29
29: ; preds = %17
%30 = load i32, i32* %6
%31 = add nsw i32 %30, -1
store i32 %31, i32* %6
br label %14
32: ; preds = %14
store i32 0, i32* %6
br label %33
33: ; preds = %41, %32
%34 = load i32, i32* %5
%35 = icmp ne i32 %34, 0
br i1 %35, label %36, label %46
36: ; preds = %33
%37 = load i8*, i8** %3
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
store i8 48, i8* %40
br label %41
41: ; preds = %36
%42 = load i32, i32* %5
%43 = add nsw i32 %42, -1
store i32 %43, i32* %5
%44 = load i32, i32* %6
%45 = add nsw i32 %44, 1
store i32 %45, i32* %6
br label %33
46: ; preds = %33
ret void
}

LLVM IR (-O2):
define void @add_0(i8* %0, i32 %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = sub nsw i32 %1, %3
%5 = icmp sgt i32 %3, -1
br i1 %5, label %6, label %140
6: ; preds = %2
%7 = zext i32 %3 to i64
%8 = add nuw nsw i64 %7, 1
%9 = icmp ult i32 %3, 3
br i1 %9, label %120, label %10
10: ; preds = %6
%11 = sub i32 %1, %3
%12 = icmp sgt i32 %11, %1
%13 = sext i32 %1 to i64
%14 = getelementptr i8, i8* %0, i64 %13
%15 = sub nsw i64 0, %7
%16 = getelementptr i8, i8* %14, i64 %15
%17 = icmp ugt i8* %16, %14
%18 = getelementptr i8, i8* %0, i64 %7
%19 = icmp ult i8* %18, %0
%20 = or i1 %12, %17
%21 = or i1 %20, %19
br i1 %21, label %120, label %22
22: ; preds = %10
%23 = sext i32 %1 to i64
%24 = sub nsw i64 %23, %7
%25 = getelementptr i8, i8* %0, i64 %24
%26 = add nsw i64 %23, 1
%27 = getelementptr i8, i8* %0, i64 %26
%28 = add nuw nsw i64 %7, 1
%29 = getelementptr i8, i8* %0, i64 %28
%30 = icmp ult i8* %25, %29
%31 = icmp ugt i8* %27, %0
%32 = and i1 %30, %31
br i1 %32, label %120, label %33
33: ; preds = %22
%34 = icmp ult i32 %3, 15
br i1 %34, label %97, label %35
35: ; preds = %33
%36 = and i64 %8, 8589934576
%37 = add nsw i64 %36, -16
%38 = lshr exact i64 %37, 4
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %39, 1
%41 = icmp eq i64 %37, 0
br i1 %41, label %75, label %42
42: ; preds = %35
%43 = and i64 %39, 2305843009213693950
%44 = getelementptr inbounds i8, i8* %0, i64 -15
%45 = getelementptr inbounds i8, i8* %0, i64 -15
%46 = getelementptr inbounds i8, i8* %0, i64 -15
%47 = getelementptr inbounds i8, i8* %0, i64 -15
br label %48
48: ; preds = %48, %42
%49 = phi i64 [ 0, %42 ], [ %72, %48 ]
%50 = phi i64 [ 0, %42 ], [ %73, %48 ]
%51 = sub i64 %7, %49
%52 = trunc i64 %49 to i32
%53 = sub i32 %3, %52
%54 = getelementptr inbounds i8, i8* %44, i64 %51
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = add nsw i32 %4, %53
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %45, i64 %58
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %60
%61 = or i64 %49, 16
%62 = sub i64 %7, %61
%63 = trunc i64 %61 to i32
%64 = sub i32 %3, %63
%65 = getelementptr inbounds i8, i8* %46, i64 %62
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = add nsw i32 %4, %64
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %47, i64 %69
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %71
%72 = add nuw i64 %49, 32
%73 = add i64 %50, 2
%74 = icmp eq i64 %73, %43
br i1 %74, label %75, label %48
75: ; preds = %48, %35
%76 = phi i64 [ 0, %35 ], [ %72, %48 ]
%77 = icmp eq i64 %40, 0
br i1 %77, label %91, label %78
78: ; preds = %75
%79 = sub i64 %7, %76
%80 = trunc i64 %76 to i32
%81 = sub i32 %3, %80
%82 = getelementptr inbounds i8, i8* %0, i64 -15
%83 = getelementptr inbounds i8, i8* %82, i64 %79
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = add nsw i32 %4, %81
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %0, i64 -15
%89 = getelementptr inbounds i8, i8* %88, i64 %87
%90 = bitcast i8* %89 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %90
br label %91
91: ; preds = %75, %78
%92 = icmp eq i64 %8, %36
br i1 %92, label %140, label %93
93: ; preds = %91
%94 = sub nsw i64 %7, %36
%95 = and i64 %8, 12
%96 = icmp eq i64 %95, 0
br i1 %96, label %120, label %97
97: ; preds = %33, %93
%98 = phi i64 [ %36, %93 ], [ 0, %33 ]
%99 = add nuw nsw i64 %7, 1
%100 = and i64 %99, 8589934588
%101 = sub nsw i64 %7, %100
%102 = getelementptr inbounds i8, i8* %0, i64 -3
%103 = getelementptr inbounds i8, i8* %0, i64 -3
br label %104
104: ; preds = %104, %97
%105 = phi i64 [ %98, %97 ], [ %116, %104 ]
%106 = sub i64 %7, %105
%107 = trunc i64 %105 to i32
%108 = sub i32 %3, %107
%109 = getelementptr inbounds i8, i8* %102, i64 %106
%110 = bitcast i8* %109 to <4 x i8>*
%111 = load <4 x i8>, <4 x i8>* %110
%112 = add nsw i32 %4, %108
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %103, i64 %113
%115 = bitcast i8* %114 to <4 x i8>*
store <4 x i8> %111, <4 x i8>* %115
%116 = add nuw i64 %105, 4
%117 = icmp eq i64 %116, %100
br i1 %117, label %118, label %104
118: ; preds = %104
%119 = icmp eq i64 %99, %100
br i1 %119, label %140, label %120
120: ; preds = %22, %10, %6, %93, %118
%121 = phi i64 [ %7, %6 ], [ %7, %22 ], [ %7, %10 ], [ %94, %93 ], [ %101, %118 ]
%122 = add nsw i64 %121, 1
%123 = and i64 %122, 3
%124 = icmp eq i64 %123, 0
br i1 %124, label %137, label %125
125: ; preds = %120, %125
%126 = phi i64 [ %134, %125 ], [ %121, %120 ]
%127 = phi i64 [ %135, %125 ], [ 0, %120 ]
%128 = trunc i64 %126 to i32
%129 = getelementptr inbounds i8, i8* %0, i64 %126
%130 = load i8, i8* %129
%131 = add nsw i32 %4, %128
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i8, i8* %0, i64 %132
store i8 %130, i8* %133
%134 = add nsw i64 %126, -1
%135 = add i64 %127, 1
%136 = icmp eq i64 %135, %123
br i1 %136, label %137, label %125
137: ; preds = %125, %120
%138 = phi i64 [ %121, %120 ], [ %134, %125 ]
%139 = icmp ult i64 %121, 3
br i1 %139, label %140, label %147
140: ; preds = %137, %147, %91, %118, %2
%141 = icmp eq i32 %4, 0
br i1 %141, label %178, label %142
142: ; preds = %140
%143 = xor i32 %3, -1
%144 = add i32 %143, %1
%145 = zext i32 %144 to i64
%146 = add nuw nsw i64 %145, 1
br label %178
147: ; preds = %137, %147
%148 = phi i64 [ %176, %147 ], [ %138, %137 ]
%149 = trunc i64 %148 to i32
%150 = getelementptr inbounds i8, i8* %0, i64 %148
%151 = load i8, i8* %150
%152 = add nsw i32 %4, %149
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %0, i64 %153
store i8 %151, i8* %154
%155 = add nsw i64 %148, -1
%156 = trunc i64 %155 to i32
%157 = getelementptr inbounds i8, i8* %0, i64 %155
%158 = load i8, i8* %157
%159 = add nsw i32 %4, %156
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i8, i8* %0, i64 %160
store i8 %158, i8* %161
%162 = add nsw i64 %148, -2
%163 = trunc i64 %162 to i32
%164 = getelementptr inbounds i8, i8* %0, i64 %162
%165 = load i8, i8* %164
%166 = add nsw i32 %4, %163
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i8, i8* %0, i64 %167
store i8 %165, i8* %168
%169 = add nsw i64 %148, -3
%170 = trunc i64 %169 to i32
%171 = getelementptr inbounds i8, i8* %0, i64 %169
%172 = load i8, i8* %171
%173 = add nsw i32 %4, %170
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %0, i64 %174
store i8 %172, i8* %175
%176 = add nsw i64 %148, -4
%177 = icmp eq i64 %169, 0
br i1 %177, label %140, label %147
178: ; preds = %142, %140
ret void
}