int addspace(char *string, int amount) {
  int i, ii;
  i = 0;
  while (string[i++] != '\0')
    ;
  ii = i + amount;
  while (--i != -1) {
    --ii;
    string[ii] = string[i];
  }
  while (--ii != -1)
    string[ii] = ' ';
}


x86 assembly (clang, -O0):
<addspace>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1136 <addspace+0x36>
jmp    1112 <addspace+0x12>
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
cmp    $0xffffffff,%eax
je     1175 <addspace+0x75>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    113f <addspace+0x3f>
jmp    117a <addspace+0x7a>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0xffffffff,%eax
je     119d <addspace+0x9d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    117a <addspace+0x7a>
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<addspace>:
push   %r15
push   %r14
push   %rbx
movabs $0xffffffff00000000,%rax
ff ff ff
xor    %edx,%edx
movabs $0x100000000,%rcx
nopl   0x0(%rax,%rax,1)
add    %rcx,%rax
cmpb   $0x0,(%rdi,%rdx,1)
lea    0x1(%rdx),%rdx
jne    1130 <addspace+0x20>
mov    %esi,%r14d
add    %rdx,%r14
sar    $0x20,%rax
movslq %r14d,%r11
lea    0x1(%rax),%r9
cmp    $0x10,%r9
jb     119a <addspace+0x8a>
lea    (%r11,%rdi,1),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,%rsi
sub    %rax,%rsi
cmp    %rcx,%rsi
ja     119a <addspace+0x8a>
lea    (%rdi,%rax,1),%rcx
cmp    %rdi,%rcx
jb     119a <addspace+0x8a>
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
add    %rdi,%rcx
lea    (%rax,%rdi,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rcx
jae    126e <addspace+0x15e>
lea    (%rdi,%r11,1),%rcx
cmp    %rdi,%rcx
jbe    126e <addspace+0x15e>
mov    %r11,%r10
lea    0x1(%rax),%ecx
and    $0x3,%rcx
je     11e7 <addspace+0xd7>
lea    (%r10,%rdi,1),%r8
add    $0xffffffffffffffff,%r8
lea    (%rdi,%rax,1),%rdx
neg    %rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,(%r8,%rsi,1)
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%rcx
jne    11c0 <addspace+0xb0>
lea    (%r10,%rsi,1),%r11
add    $0x1,%r11
add    %rsi,%r10
add    %rax,%rsi
cmp    $0x3,%rax
jae    11f0 <addspace+0xe0>
jmp    1246 <addspace+0x136>
mov    %rax,%rsi
cmp    $0x3,%rax
jb     1246 <addspace+0x136>
lea    (%r10,%rdi,1),%rax
add    $0xffffffffffffffff,%rax
lea    (%rdi,%rsi,1),%rcx
not    %rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rbx,1),%edx
mov    %dl,(%rax,%rbx,1)
movzbl -0x1(%rcx,%rbx,1),%edx
mov    %dl,-0x1(%rax,%rbx,1)
movzbl -0x2(%rcx,%rbx,1),%edx
mov    %dl,-0x2(%rax,%rbx,1)
movzbl -0x3(%rcx,%rbx,1),%edx
mov    %dl,-0x3(%rax,%rbx,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rsi
jne    1210 <addspace+0x100>
lea    (%r10,%rbx,1),%r11
add    $0x1,%r11
add    %rbx,%r10
test   %r10d,%r10d
je     1268 <addspace+0x158>
add    $0xfffffffe,%r11d
movslq %r11d,%rax
mov    %eax,%edx
sub    %rdx,%rax
add    %rax,%rdi
add    $0x1,%rdx
mov    $0x20,%esi
call   1030 <memset@plt>
pop    %rbx
pop    %r14
pop    %r15
ret
add    $0xffffffffffffffff,%rdx
mov    %r9,%r8
and    $0xfffffffffffffff0,%r8
lea    -0x10(%r8),%rcx
mov    %rcx,%r10
shr    $0x4,%r10
add    $0x1,%r10
cmp    $0x30,%rcx
jae    129b <addspace+0x18b>
xor    %ecx,%ecx
test   $0x3,%r10b
jne    130d <addspace+0x1fd>
jmp    1365 <addspace+0x255>
movslq %edx,%rbx
lea    (%rdi,%rbx,1),%r15
add    $0xfffffffffffffff1,%r15
movslq %r14d,%rcx
lea    (%rdi,%rcx,1),%rsi
add    $0xfffffffffffffff0,%rsi
add    $0x1,%rbx
and    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffff0,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%r15,%rcx,1),%xmm0
movups %xmm0,(%rsi,%rcx,1)
movups -0x10(%r15,%rcx,1),%xmm0
movups %xmm0,-0x10(%rsi,%rcx,1)
movups -0x20(%r15,%rcx,1),%xmm0
movups %xmm0,-0x20(%rsi,%rcx,1)
movups -0x30(%r15,%rcx,1),%xmm0
movups %xmm0,-0x30(%rsi,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%rbx
jne    12d0 <addspace+0x1c0>
neg    %rcx
test   $0x3,%r10b
je     1365 <addspace+0x255>
movslq %r14d,%rsi
mov    %rdi,%rbx
sub    %rcx,%rbx
lea    (%rbx,%rsi,1),%r10
add    $0xfffffffffffffff0,%r10
movslq %edx,%rsi
add    %rbx,%rsi
add    $0xfffffffffffffff1,%rsi
add    $0x1,%dl
and    $0x30,%dl
add    $0xf0,%dl
shr    $0x4,%dl
add    $0x1,%dl
movzbl %dl,%ecx
and    $0x3,%ecx
shl    $0x4,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r10,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %rcx,%rdx
add    %rbx,%rdx
jne    1350 <addspace+0x240>
mov    %r11,%r10
sub    %r8,%r10
cmp    %r8,%r9
jne    1385 <addspace+0x275>
sub    %r8,%r11
add    $0x1,%r11
test   %r10d,%r10d
jne    124b <addspace+0x13b>
jmp    1268 <addspace+0x158>
sub    %r8,%rax
jmp    119d <addspace+0x8d>

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

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