#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 */
size_t strlen(char *);
void lowercase(char *in) {
  size_t Bound = strlen(in), ix = 0;
  for (ix = 0; ix < Bound; ix++) {
    if (in[ix] >= 'A' && in[ix] <= 'Z') {
      in[ix] |= 0x20;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<lowercase>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1199 <lowercase+0x89>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1183 <lowercase+0x73>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     1183 <lowercase+0x73>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
or     $0x20,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1188 <lowercase+0x78>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1139 <lowercase+0x29>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lowercase>:
push   %rbx
mov    %rdi,%rbx
call   1030 <strlen@plt>
test   %rax,%rax
je     12ac <lowercase+0x19c>
cmp    $0x8,%rax
jae    112f <lowercase+0x1f>
xor    %ecx,%ecx
jmp    1294 <lowercase+0x184>
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
xor    %edx,%edx
movdqa 0xec0(%rip),%xmm0
movdqa 0xec8(%rip),%xmm1
pcmpeqd %xmm2,%xmm2
jmp    115d <lowercase+0x4d>
xchg   %ax,%ax
add    $0x8,%rdx
cmp    %rdx,%rcx
je     128f <lowercase+0x17f>
movq   (%rbx,%rdx,1),%xmm3
movdqa %xmm3,%xmm4
paddb  %xmm0,%xmm4
movdqa %xmm4,%xmm5
pmaxub %xmm1,%xmm5
pcmpeqb %xmm4,%xmm5
movd   %xmm5,%esi
not    %sil
test   $0x1,%sil
je     118f <lowercase+0x7f>
movd   %xmm3,%esi
or     $0x20,%sil
mov    %sil,(%rbx,%rdx,1)
movdqa %xmm5,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,%xmm6
pslld  $0x8,%xmm6
movd   %xmm6,%esi
shr    $0x10,%esi
test   $0x1,%sil
je     11bd <lowercase+0xad>
movd   %xmm3,%esi
shr    $0x8,%esi
or     $0x20,%sil
mov    %sil,0x1(%rbx,%rdx,1)
pshuflw $0x55,%xmm5,%xmm6
pxor   %xmm2,%xmm6
pextrw $0x2,%xmm6,%esi
test   $0x1,%sil
je     11e1 <lowercase+0xd1>
movd   %xmm3,%esi
shr    $0x10,%esi
or     $0x20,%sil
mov    %sil,0x2(%rbx,%rdx,1)
movdqa %xmm4,%xmm6
psllq  $0x18,%xmm6
pextrw $0x3,%xmm6,%esi
test   $0x1,%sil
je     1205 <lowercase+0xf5>
movd   %xmm3,%esi
shr    $0x18,%esi
or     $0x20,%sil
mov    %sil,0x3(%rbx,%rdx,1)
pshufd $0x55,%xmm5,%xmm5
pxor   %xmm2,%xmm5
pextrw $0x4,%xmm5,%esi
test   $0x1,%sil
je     1227 <lowercase+0x117>
pextrw $0x2,%xmm3,%esi
or     $0x20,%sil
mov    %sil,0x4(%rbx,%rdx,1)
movdqa %xmm4,%xmm5
pslldq $0x5,%xmm5
pextrw $0x5,%xmm5,%esi
test   $0x1,%sil
je     124c <lowercase+0x13c>
pextrw $0x2,%xmm3,%esi
shr    $0x8,%esi
or     $0x20,%sil
mov    %sil,0x5(%rbx,%rdx,1)
pextrw $0x3,%xmm4,%esi
test   $0x1,%sil
je     1265 <lowercase+0x155>
pextrw $0x3,%xmm3,%esi
or     $0x20,%sil
mov    %sil,0x6(%rbx,%rdx,1)
pslldq $0x7,%xmm4
pextrw $0x7,%xmm4,%esi
test   $0x1,%sil
je     1150 <lowercase+0x40>
pextrw $0x3,%xmm3,%esi
shr    $0x8,%esi
or     $0x20,%sil
mov    %sil,0x7(%rbx,%rdx,1)
jmp    1150 <lowercase+0x40>
cmp    %rcx,%rax
je     12ac <lowercase+0x19c>
mov    (%rbx,%rcx,1),%dl
lea    -0x41(%rdx),%esi
cmp    $0x19,%sil
ja     12a6 <lowercase+0x196>
or     $0x20,%dl
mov    %dl,(%rbx,%rcx,1)
add    $0x1,%rcx
jmp    128f <lowercase+0x17f>
pop    %rbx
ret

LLVM IR (-O0):
define void @lowercase(i8* %0) {
%2 = alloca i8*
%3 = alloca i64
%4 = alloca i64
store i8* %0, i8** %2
%5 = load i8*, i8** %2
%6 = call i64 @strlen(i8* %5)
store i64 %6, i64* %3
store i64 0, i64* %4
store i64 0, i64* %4
br label %7
7: ; preds = %34, %1
%8 = load i64, i64* %4
%9 = load i64, i64* %3
%10 = icmp ult i64 %8, %9
br i1 %10, label %11, label %37
11: ; preds = %7
%12 = load i8*, i8** %2
%13 = load i64, i64* %4
%14 = getelementptr inbounds i8, i8* %12, i64 %13
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = icmp sge i32 %16, 65
br i1 %17, label %18, label %33
18: ; preds = %11
%19 = load i8*, i8** %2
%20 = load i64, i64* %4
%21 = getelementptr inbounds i8, i8* %19, i64 %20
%22 = load i8, i8* %21
%23 = sext i8 %22 to i32
%24 = icmp sle i32 %23, 90
br i1 %24, label %25, label %33
25: ; preds = %18
%26 = load i8*, i8** %2
%27 = load i64, i64* %4
%28 = getelementptr inbounds i8, i8* %26, i64 %27
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = or i32 %30, 32
%32 = trunc i32 %31 to i8
store i8 %32, i8* %28
br label %33
33: ; preds = %25, %18, %11
br label %34
34: ; preds = %33
%35 = load i64, i64* %4
%36 = add i64 %35, 1
store i64 %36, i64* %4
br label %7
37: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @lowercase(i8* nocapture %0) {
%2 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%3 = icmp eq i64 %2, 0
br i1 %3, label %87, label %4
4: ; preds = %1
%5 = icmp ult i64 %2, 8
br i1 %5, label %74, label %6
6: ; preds = %4
%7 = and i64 %2, -8
br label %8
8: ; preds = %69, %6
%9 = phi i64 [ 0, %6 ], [ %70, %69 ]
%10 = getelementptr inbounds i8, i8* %0, i64 %9
%11 = bitcast i8* %10 to <8 x i8>*
%12 = load <8 x i8>, <8 x i8>* %11
%13 = add <8 x i8> %12, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%14 = icmp ult <8 x i8> %13, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%15 = extractelement <8 x i1> %14, i64 0
br i1 %15, label %16, label %20
16: ; preds = %8
%17 = extractelement <8 x i8> %12, i64 0
%18 = or i8 %17, 32
%19 = getelementptr inbounds i8, i8* %0, i64 %9
store i8 %18, i8* %19
br label %20
20: ; preds = %16, %8
%21 = extractelement <8 x i1> %14, i64 1
br i1 %21, label %22, label %27
22: ; preds = %20
%23 = or i64 %9, 1
%24 = extractelement <8 x i8> %12, i64 1
%25 = or i8 %24, 32
%26 = getelementptr inbounds i8, i8* %0, i64 %23
store i8 %25, i8* %26
br label %27
27: ; preds = %22, %20
%28 = extractelement <8 x i1> %14, i64 2
br i1 %28, label %29, label %34
29: ; preds = %27
%30 = or i64 %9, 2
%31 = extractelement <8 x i8> %12, i64 2
%32 = or i8 %31, 32
%33 = getelementptr inbounds i8, i8* %0, i64 %30
store i8 %32, i8* %33
br label %34
34: ; preds = %29, %27
%35 = extractelement <8 x i1> %14, i64 3
br i1 %35, label %36, label %41
36: ; preds = %34
%37 = or i64 %9, 3
%38 = extractelement <8 x i8> %12, i64 3
%39 = or i8 %38, 32
%40 = getelementptr inbounds i8, i8* %0, i64 %37
store i8 %39, i8* %40
br label %41
41: ; preds = %36, %34
%42 = extractelement <8 x i1> %14, i64 4
br i1 %42, label %43, label %48
43: ; preds = %41
%44 = or i64 %9, 4
%45 = extractelement <8 x i8> %12, i64 4
%46 = or i8 %45, 32
%47 = getelementptr inbounds i8, i8* %0, i64 %44
store i8 %46, i8* %47
br label %48
48: ; preds = %43, %41
%49 = extractelement <8 x i1> %14, i64 5
br i1 %49, label %50, label %55
50: ; preds = %48
%51 = or i64 %9, 5
%52 = extractelement <8 x i8> %12, i64 5
%53 = or i8 %52, 32
%54 = getelementptr inbounds i8, i8* %0, i64 %51
store i8 %53, i8* %54
br label %55
55: ; preds = %50, %48
%56 = extractelement <8 x i1> %14, i64 6
br i1 %56, label %57, label %62
57: ; preds = %55
%58 = or i64 %9, 6
%59 = extractelement <8 x i8> %12, i64 6
%60 = or i8 %59, 32
%61 = getelementptr inbounds i8, i8* %0, i64 %58
store i8 %60, i8* %61
br label %62
62: ; preds = %57, %55
%63 = extractelement <8 x i1> %14, i64 7
br i1 %63, label %64, label %69
64: ; preds = %62
%65 = or i64 %9, 7
%66 = extractelement <8 x i8> %12, i64 7
%67 = or i8 %66, 32
%68 = getelementptr inbounds i8, i8* %0, i64 %65
store i8 %67, i8* %68
br label %69
69: ; preds = %64, %62
%70 = add nuw i64 %9, 8
%71 = icmp eq i64 %70, %7
br i1 %71, label %72, label %8
72: ; preds = %69
%73 = icmp eq i64 %2, %7
br i1 %73, label %87, label %74
74: ; preds = %4, %72
%75 = phi i64 [ 0, %4 ], [ %7, %72 ]
br label %76
76: ; preds = %74, %84
%77 = phi i64 [ %85, %84 ], [ %75, %74 ]
%78 = getelementptr inbounds i8, i8* %0, i64 %77
%79 = load i8, i8* %78
%80 = add i8 %79, -65
%81 = icmp ult i8 %80, 26
br i1 %81, label %82, label %84
82: ; preds = %76
%83 = or i8 %79, 32
store i8 %83, i8* %78
br label %84
84: ; preds = %76, %82
%85 = add nuw i64 %77, 1
%86 = icmp eq i64 %85, %2
br i1 %86, label %87, label %76
87: ; preds = %84, %72, %1
ret void
}