#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*/ bar(char *);
void foo(int x, int y) {
  int i;
  signed char a[123], b[123], c;
  for (i = 0; i < 123; i++) {
    int e = y - x;
    int d = e < 0 ? -e : e;
    c = d < 75;
    a[y] = c;
    b[y] = c;
    y--;
  }
  bar(b);
  bar(a);
}


x86 assembly (clang, -O0):
<foo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x7b,-0xc(%rbp)
jge    11c4 <foo+0xb4>
mov    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x118(%rbp)
cmpl   $0x0,-0x118(%rbp)
jge    115e <foo+0x4e>
xor    %eax,%eax
sub    -0x118(%rbp),%eax
mov    %eax,-0x120(%rbp)
jmp    116a <foo+0x5a>
mov    -0x118(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    %eax,-0x11c(%rbp)
cmpl   $0x4b,-0x11c(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %al,-0x111(%rbp)
mov    -0x111(%rbp),%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x90(%rbp,%rax,1)
mov    -0x111(%rbp),%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1128 <foo+0x18>
lea    -0x110(%rbp),%rdi
call   1030 <bar@plt>
lea    -0x90(%rbp),%rdi
call   1030 <bar@plt>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<foo>:
sub    $0x108,%rsp
movslq %esi,%rax
lea    -0x70(%rax),%r8
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm4
movdqa 0xed0(%rip),%xmm14
paddd  %xmm4,%xmm14
movdqa 0xed3(%rip),%xmm6
paddd  %xmm4,%xmm6
movdqa 0xed7(%rip),%xmm7
paddd  %xmm4,%xmm7
paddd  0xedb(%rip),%xmm4
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm13
lea    0x80(%rsp,%rax,1),%rdx
lea    (%rsp,%rax,1),%rsi
mov    $0xfffffffffffffff1,%rcx
movdqa 0xec5(%rip),%xmm10
movdqa 0xecc(%rip),%xmm11
movdqa 0xed3(%rip),%xmm8
pxor   %xmm9,%xmm9
movdqa 0xed5(%rip),%xmm12
nopl   0x0(%rax,%rax,1)
movdqa %xmm4,%xmm0
psubd  %xmm13,%xmm0
movdqa %xmm7,%xmm3
psubd  %xmm13,%xmm3
movdqa %xmm6,%xmm2
psubd  %xmm13,%xmm2
movdqa %xmm14,%xmm5
psubd  %xmm13,%xmm5
movdqa %xmm5,%xmm1
psrad  $0x1f,%xmm1
paddd  %xmm1,%xmm5
pxor   %xmm1,%xmm5
movdqa %xmm2,%xmm1
psrad  $0x1f,%xmm1
paddd  %xmm1,%xmm2
pxor   %xmm1,%xmm2
movdqa %xmm3,%xmm1
psrad  $0x1f,%xmm1
paddd  %xmm1,%xmm3
pxor   %xmm1,%xmm3
movdqa %xmm0,%xmm1
psrad  $0x1f,%xmm1
paddd  %xmm1,%xmm0
pxor   %xmm1,%xmm0
pxor   %xmm10,%xmm0
movdqa %xmm11,%xmm1
pcmpgtd %xmm0,%xmm1
pxor   %xmm10,%xmm3
movdqa %xmm11,%xmm0
pcmpgtd %xmm3,%xmm0
packssdw %xmm0,%xmm1
pxor   %xmm10,%xmm2
movdqa %xmm11,%xmm0
pcmpgtd %xmm2,%xmm0
pxor   %xmm10,%xmm5
movdqa %xmm11,%xmm2
pcmpgtd %xmm5,%xmm2
packssdw %xmm2,%xmm0
packsswb %xmm0,%xmm1
pand   %xmm8,%xmm1
movdqa %xmm1,%xmm0
punpcklbw %xmm9,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
punpckhbw %xmm9,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,(%rdx,%rcx,1)
movdqu %xmm1,(%rsi,%rcx,1)
paddd  %xmm12,%xmm4
paddd  %xmm12,%xmm7
paddd  %xmm12,%xmm6
paddd  %xmm12,%xmm14
add    $0xfffffffffffffff0,%rcx
cmp    $0xffffffffffffff81,%rcx
jne    11a0 <foo+0x90>
sub    %edi,%r8d
mov    %r8d,%ecx
neg    %ecx
cmovs  %r8d,%ecx
cmp    $0x4b,%ecx
setb   0x10(%rsp,%rax,1)
setb   -0x70(%rsp,%rax,1)
lea    -0x71(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xf(%rsp,%rax,1)
setb   -0x71(%rsp,%rax,1)
lea    -0x72(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xe(%rsp,%rax,1)
setb   -0x72(%rsp,%rax,1)
lea    -0x73(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xd(%rsp,%rax,1)
setb   -0x73(%rsp,%rax,1)
lea    -0x74(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xc(%rsp,%rax,1)
setb   -0x74(%rsp,%rax,1)
lea    -0x75(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xb(%rsp,%rax,1)
setb   -0x75(%rsp,%rax,1)
lea    -0x76(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0xa(%rsp,%rax,1)
setb   -0x76(%rsp,%rax,1)
lea    -0x77(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0x9(%rsp,%rax,1)
setb   -0x77(%rsp,%rax,1)
lea    -0x78(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0x8(%rsp,%rax,1)
setb   -0x78(%rsp,%rax,1)
lea    -0x79(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0x7(%rsp,%rax,1)
setb   -0x79(%rsp,%rax,1)
lea    -0x7a(%rax),%rcx
sub    %edi,%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
cmp    $0x4b,%edx
setb   0x6(%rsp,%rax,1)
setb   -0x7a(%rsp,%rax,1)
mov    %rsp,%rdi
call   1030 <bar@plt>
lea    0x80(%rsp),%rdi
call   1030 <bar@plt>
add    $0x108,%rsp
ret

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

LLVM IR (-O2):
define void @foo(i32 %0, i32 %1) {
%3 = alloca [123 x i8]
%4 = alloca [123 x i8]
%5 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 0
%6 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 0
%7 = sext i32 %1 to i64
%8 = add nsw i64 %7, -112
%9 = insertelement <16 x i32> poison, i32 %1, i64 0
%10 = shufflevector <16 x i32> %9, <16 x i32> poison, <16 x i32> zeroinitializer
%11 = add <16 x i32> %10, <i32 0, i32 -1, i32 -2, i32 -3, i32 -4, i32 -5, i32 -6, i32 -7, i32 -8, i32 -9, i32 -10, i32 -11, i32 -12, i32 -13, i32 -14, i32 -15>
%12 = insertelement <16 x i32> poison, i32 %0, i64 0
%13 = shufflevector <16 x i32> %12, <16 x i32> poison, <16 x i32> zeroinitializer
br label %14
14: ; preds = %14, %2
%15 = phi i64 [ 0, %2 ], [ %29, %14 ]
%16 = phi <16 x i32> [ %11, %2 ], [ %30, %14 ]
%17 = sub i64 %7, %15
%18 = sub <16 x i32> %16, %13
%19 = call <16 x i32> @llvm.abs.v16i32(<16 x i32> %18, i1 true)
%20 = icmp ult <16 x i32> %19, <i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75, i32 75>
%21 = zext <16 x i1> %20 to <16 x i8>
%22 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %17
%23 = shufflevector <16 x i8> %21, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%24 = getelementptr inbounds i8, i8* %22, i64 -15
%25 = bitcast i8* %24 to <16 x i8>*
store <16 x i8> %23, <16 x i8>* %25
%26 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %17
%27 = getelementptr inbounds i8, i8* %26, i64 -15
%28 = bitcast i8* %27 to <16 x i8>*
store <16 x i8> %23, <16 x i8>* %28
%29 = add nuw i64 %15, 16
%30 = add <16 x i32> %16, <i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16, i32 -16>
%31 = icmp eq i64 %29, 112
br i1 %31, label %32, label %14
32: ; preds = %14
%33 = trunc i64 %8 to i32
%34 = sub i32 %33, %0
%35 = tail call i32 @llvm.abs.i32(i32 %34, i1 true)
%36 = icmp ult i32 %35, 75
%37 = zext i1 %36 to i8
%38 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %8
store i8 %37, i8* %38
%39 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %8
store i8 %37, i8* %39
%40 = add nsw i64 %7, -113
%41 = trunc i64 %40 to i32
%42 = sub i32 %41, %0
%43 = tail call i32 @llvm.abs.i32(i32 %42, i1 true)
%44 = icmp ult i32 %43, 75
%45 = zext i1 %44 to i8
%46 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %40
store i8 %45, i8* %46
%47 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %40
store i8 %45, i8* %47
%48 = add nsw i64 %7, -114
%49 = trunc i64 %48 to i32
%50 = sub i32 %49, %0
%51 = tail call i32 @llvm.abs.i32(i32 %50, i1 true)
%52 = icmp ult i32 %51, 75
%53 = zext i1 %52 to i8
%54 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %48
store i8 %53, i8* %54
%55 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %48
store i8 %53, i8* %55
%56 = add nsw i64 %7, -115
%57 = trunc i64 %56 to i32
%58 = sub i32 %57, %0
%59 = tail call i32 @llvm.abs.i32(i32 %58, i1 true)
%60 = icmp ult i32 %59, 75
%61 = zext i1 %60 to i8
%62 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %56
store i8 %61, i8* %62
%63 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %56
store i8 %61, i8* %63
%64 = add nsw i64 %7, -116
%65 = trunc i64 %64 to i32
%66 = sub i32 %65, %0
%67 = tail call i32 @llvm.abs.i32(i32 %66, i1 true)
%68 = icmp ult i32 %67, 75
%69 = zext i1 %68 to i8
%70 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %64
store i8 %69, i8* %70
%71 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %64
store i8 %69, i8* %71
%72 = add nsw i64 %7, -117
%73 = trunc i64 %72 to i32
%74 = sub i32 %73, %0
%75 = tail call i32 @llvm.abs.i32(i32 %74, i1 true)
%76 = icmp ult i32 %75, 75
%77 = zext i1 %76 to i8
%78 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %72
store i8 %77, i8* %78
%79 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %72
store i8 %77, i8* %79
%80 = add nsw i64 %7, -118
%81 = trunc i64 %80 to i32
%82 = sub i32 %81, %0
%83 = tail call i32 @llvm.abs.i32(i32 %82, i1 true)
%84 = icmp ult i32 %83, 75
%85 = zext i1 %84 to i8
%86 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %80
store i8 %85, i8* %86
%87 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %80
store i8 %85, i8* %87
%88 = add nsw i64 %7, -119
%89 = trunc i64 %88 to i32
%90 = sub i32 %89, %0
%91 = tail call i32 @llvm.abs.i32(i32 %90, i1 true)
%92 = icmp ult i32 %91, 75
%93 = zext i1 %92 to i8
%94 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %88
store i8 %93, i8* %94
%95 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %88
store i8 %93, i8* %95
%96 = add nsw i64 %7, -120
%97 = trunc i64 %96 to i32
%98 = sub i32 %97, %0
%99 = tail call i32 @llvm.abs.i32(i32 %98, i1 true)
%100 = icmp ult i32 %99, 75
%101 = zext i1 %100 to i8
%102 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %96
store i8 %101, i8* %102
%103 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %96
store i8 %101, i8* %103
%104 = add nsw i64 %7, -121
%105 = trunc i64 %104 to i32
%106 = sub i32 %105, %0
%107 = tail call i32 @llvm.abs.i32(i32 %106, i1 true)
%108 = icmp ult i32 %107, 75
%109 = zext i1 %108 to i8
%110 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %104
store i8 %109, i8* %110
%111 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %104
store i8 %109, i8* %111
%112 = add nsw i64 %7, -122
%113 = trunc i64 %112 to i32
%114 = sub i32 %113, %0
%115 = tail call i32 @llvm.abs.i32(i32 %114, i1 true)
%116 = icmp ult i32 %115, 75
%117 = zext i1 %116 to i8
%118 = getelementptr inbounds [123 x i8], [123 x i8]* %3, i64 0, i64 %112
store i8 %117, i8* %118
%119 = getelementptr inbounds [123 x i8], [123 x i8]* %4, i64 0, i64 %112
store i8 %117, i8* %119
%120 = call i32 @bar(i8* %6)
%121 = call i32 @bar(i8* %5)
ret void
}