#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 ltrim(char *str) {
  int i = 0, j, len = strlen(str);
  while (str[i] != '\0') {
    if (str[i] != 32 && str[i] != 9)
      break;
    i++;
  }
  if (i != 0)
    for (j = 0; j <= len - i; j++) {
      str[j] = str[j + i];
    }
}


x86 assembly (clang, -O0):
<ltrim>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1181 <ltrim+0x71>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1173 <ltrim+0x63>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
je     1173 <ltrim+0x63>
jmp    1181 <ltrim+0x71>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    112f <ltrim+0x1f>
cmpl   $0x0,-0xc(%rbp)
je     11d1 <ltrim+0xc1>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jg     11cc <ltrim+0xbc>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1192 <ltrim+0x82>
jmp    11d1 <ltrim+0xc1>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ltrim>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
call   1030 <strlen@plt>
lea    0x1(%rax),%esi
lea    0x1(%rax),%edx
xor    %ecx,%ecx
jmp    1137 <ltrim+0x27>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x3,%dl
movzbl (%r14,%rcx,1),%ebx
cmp    $0x20,%bl
je     1130 <ltrim+0x20>
cmp    $0x9,%bl
je     1130 <ltrim+0x20>
test   %ecx,%ecx
je     1208 <ltrim+0xf8>
cmp    %ecx,%eax
jl     1208 <ltrim+0xf8>
mov    %esi,%r9d
sub    %rcx,%r9
sub    %rcx,%rsi
mov    %esi,%r10d
cmp    $0x8,%esi
jb     1189 <ltrim+0x79>
mov    %ecx,%eax
lea    (%rax,%r10,1),%rdi
add    %r14,%rdi
cmp    %r14,%rdi
jbe    1210 <ltrim+0x100>
lea    (%r14,%r10,1),%rdi
add    %r14,%rax
cmp    %rdi,%rax
jae    1210 <ltrim+0x100>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r10,%rax
test   $0x3,%r10b
je     11c2 <ltrim+0xb2>
mov    %ecx,%edi
add    %r14,%rdi
movzbl %dl,%edx
and    $0x3,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,(%r14,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    11b0 <ltrim+0xa0>
cmp    $0x3,%rax
jb     1208 <ltrim+0xf8>
mov    %r9d,%eax
sub    %rsi,%rax
lea    (%rsi,%r14,1),%rdx
add    $0x3,%rdx
mov    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rdx,%rcx,1),%ebx
mov    %bl,-0x3(%rdx)
movzbl -0x2(%rdx,%rcx,1),%ebx
mov    %bl,-0x2(%rdx)
movzbl -0x1(%rdx,%rcx,1),%ebx
mov    %bl,-0x1(%rdx)
movzbl (%rdx,%rcx,1),%ebx
mov    %bl,(%rdx)
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rax
jne    11e0 <ltrim+0xd0>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%esi
jae    121c <ltrim+0x10c>
xor    %esi,%esi
jmp    131f <ltrim+0x20f>
mov    %r10d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rax
mov    %rax,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rax
jae    123e <ltrim+0x12e>
xor    %edi,%edi
jmp    12c0 <ltrim+0x1b0>
mov    %ecx,%eax
add    %r14,%rax
add    $0x70,%rax
mov    %r9d,%r11d
and    $0xffffffe0,%r11d
add    $0xffffffffffffffe0,%r11
shr    $0x5,%r11
add    $0x1,%r11
and    $0xfffffffffffffffc,%r11
xor    %edi,%edi
movups -0x70(%rax,%rdi,1),%xmm0
movups -0x60(%rax,%rdi,1),%xmm1
movups %xmm0,(%r14,%rdi,1)
movups %xmm1,0x10(%r14,%rdi,1)
movups -0x50(%rax,%rdi,1),%xmm0
movups -0x40(%rax,%rdi,1),%xmm1
movups %xmm0,0x20(%r14,%rdi,1)
movups %xmm1,0x30(%r14,%rdi,1)
movups -0x30(%rax,%rdi,1),%xmm0
movups -0x20(%rax,%rdi,1),%xmm1
movups %xmm0,0x40(%r14,%rdi,1)
movups %xmm1,0x50(%r14,%rdi,1)
movups -0x10(%rax,%rdi,1),%xmm0
movups (%rax,%rdi,1),%xmm1
movups %xmm0,0x60(%r14,%rdi,1)
movups %xmm1,0x70(%r14,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%r11
jne    1260 <ltrim+0x150>
test   $0x3,%r8b
je     130c <ltrim+0x1fc>
lea    (%rdi,%r14,1),%rax
add    $0x10,%rax
mov    %ecx,%r8d
mov    %r9d,%ebx
and    $0x60,%bl
add    $0xe0,%bl
shr    $0x5,%bl
add    $0x1,%bl
movzbl %bl,%edi
and    $0x3,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rax,%r8,1),%xmm0
movups (%rax,%r8,1),%xmm1
movups %xmm0,-0x10(%rax)
movups %xmm1,(%rax)
add    $0x20,%rax
add    $0xffffffffffffffff,%rdi
jne    12f0 <ltrim+0x1e0>
cmp    %r10,%rsi
je     1208 <ltrim+0xf8>
test   $0x18,%r10b
je     118b <ltrim+0x7b>
mov    %rsi,%rax
mov    %r10d,%esi
and    $0xfffffff8,%esi
mov    %ecx,%r8d
add    %r14,%r8
mov    %r9d,%edi
and    $0xfffffff8,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r8,%rax,1),%rbx
mov    %rbx,(%r14,%rax,1)
add    $0x8,%rax
cmp    %rax,%rdi
jne    1340 <ltrim+0x230>
cmp    %r10,%rsi
je     1208 <ltrim+0xf8>
jmp    118b <ltrim+0x7b>

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

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