#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 MAP_FIXED;
int MAP_PRIVATE;
int /*<<< orphan*/ O_RDWR;
int PROT_READ;
int PROT_WRITE;
int /*<<< orphan*/ close(int);
int creat(char *, int);
int getpagesize();
scalar_t__ malloc(int);
char *mmap(char *, int, int, int, int, long);
int open(char *, int /*<<< orphan*/);
char rand();
int read(int, char *, int);
int /*<<< orphan*/ umask(int /*<<< orphan*/);
int write(int, char *, int);
int main() {
  char *data, *data2, *data3;
  int i, pagesize;
  int fd;
  pagesize = getpagesize();
  data = (char *)malloc(pagesize);
  if (!data)
    return 1;
  for (i = 0; i < pagesize; ++i)
    *(data + i) = rand();
  umask(0);
  fd = creat("conftest.mmap", 0600);
  if (fd < 0)
    return 1;
  if (write(fd, data, pagesize) != pagesize)
    return 1;
  close(fd);
  fd = open("conftest.mmap", O_RDWR);
  if (fd < 0)
    return 1;
  data2 = (char *)malloc(2 * pagesize);
  if (!data2)
    return 1;
  data2 += (pagesize - ((long int)data2 & (pagesize - 1))) & (pagesize - 1);
  if (data2 != mmap(data2, pagesize, PROT_READ | PROT_WRITE,
                    MAP_PRIVATE | MAP_FIXED, fd, 0L))
    return 1;
  for (i = 0; i < pagesize; ++i)
    if (*(data + i) != *(data2 + i))
      return 1;
  for (i = 0; i < pagesize; ++i)
    *(data2 + i) = *(data2 + i) + 1;
  data3 = (char *)malloc(pagesize);
  if (!data3)
    return 1;
  if (read(fd, data3, pagesize) != pagesize)
    return 1;
  for (i = 0; i < pagesize; ++i)
    if (*(data + i) != *(data3 + i))
      return 1;
  close(fd);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x0,%al
call   10b0 <getpagesize@plt>
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%edi
call   1080 <malloc@plt>
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    11dc <main+0x3c>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1211 <main+0x71>
mov    $0x0,%al
call   10c0 <rand@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e3 <main+0x43>
xor    %edi,%edi
call   1070 <umask@plt>
lea    0xde1(%rip),%rdi
mov    $0x180,%esi
call   10a0 <creat@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    1242 <main+0xa2>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
mov    -0x2c(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x28(%rbp),%edx
call   1030 <write@plt>
cmp    -0x28(%rbp),%eax
je     1266 <main+0xc6>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
mov    -0x2c(%rbp),%edi
call   1050 <close@plt>
mov    0x2d6b(%rip),%rax
mov    (%rax),%esi
lea    0xd82(%rip),%rdi
call   1090 <open@plt>
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    129c <main+0xfc>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
mov    -0x28(%rbp),%edi
shl    $0x1,%edi
call   1080 <malloc@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    12c2 <main+0x122>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
movslq -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
and    %rdx,%rcx
sub    %rcx,%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
and    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x28(%rbp),%esi
mov    0x2cf5(%rip),%rax
mov    (%rax),%edx
mov    0x2cc4(%rip),%rax
or     (%rax),%edx
mov    0x2cb3(%rip),%rax
mov    (%rax),%ecx
mov    0x2ca2(%rip),%rax
or     (%rax),%ecx
mov    -0x2c(%rbp),%r8d
xor    %eax,%eax
mov    %eax,%r9d
call   1040 <mmap@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
cmp    %rcx,%rax
je     134a <main+0x1aa>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    139c <main+0x1fc>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1389 <main+0x1e9>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
jmp    138e <main+0x1ee>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1351 <main+0x1b1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13d9 <main+0x239>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0x1,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13a3 <main+0x203>
mov    -0x28(%rbp),%edi
call   1080 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    13fc <main+0x25c>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
mov    -0x2c(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
call   1060 <read@plt>
cmp    -0x28(%rbp),%eax
je     1420 <main+0x280>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1472 <main+0x2d2>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     145f <main+0x2bf>
movl   $0x1,-0x4(%rbp)
jmp    1481 <main+0x2e1>
jmp    1464 <main+0x2c4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1427 <main+0x287>
mov    -0x2c(%rbp),%edi
call   1050 <close@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xor    %eax,%eax
call   10b0 <getpagesize@plt>
mov    %eax,%r15d
mov    %eax,%edi
call   1080 <malloc@plt>
mov    $0x1,%r14d
test   %rax,%rax
je     12b8 <main+0x118>
mov    %rax,%r13
test   %r15d,%r15d
jle    11f5 <main+0x55>
mov    %r15d,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10c0 <rand@plt>
mov    %al,0x0(%r13,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    11e0 <main+0x40>
xor    %edi,%edi
call   1070 <umask@plt>
lea    0xdfd(%rip),%rdi
mov    $0x180,%esi
call   10a0 <creat@plt>
test   %eax,%eax
js     12b8 <main+0x118>
mov    %eax,%ebp
mov    %eax,%edi
mov    %r13,%rsi
mov    %r15d,%edx
call   1030 <write@plt>
cmp    %r15d,%eax
jne    12b8 <main+0x118>
mov    %ebp,%edi
call   1050 <close@plt>
mov    0x2da5(%rip),%rax
mov    (%rax),%esi
lea    0xdbc(%rip),%rdi
call   1090 <open@plt>
test   %eax,%eax
js     12b8 <main+0x118>
mov    %eax,%ebp
lea    (%r15,%r15,1),%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     12b8 <main+0x118>
mov    %rax,%rbx
mov    %ebp,%r8d
movslq %r15d,%rbp
lea    -0x1(%r15),%eax
cltq
mov    %rbx,%rcx
and    %rax,%rcx
sub    %rcx,%rbp
and    %rax,%rbp
lea    (%rbx,%rbp,1),%r12
mov    0x2d75(%rip),%rax
mov    0x2d46(%rip),%rcx
mov    (%rcx),%edx
or     (%rax),%edx
mov    0x2d33(%rip),%rax
mov    0x2d24(%rip),%rcx
mov    (%rcx),%ecx
or     (%rax),%ecx
mov    %r12,%rdi
mov    %r15d,%esi
mov    %r8d,0x4(%rsp)
xor    %r9d,%r9d
call   1040 <mmap@plt>
cmp    %rax,%r12
je     12ca <main+0x12a>
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r15d,%r15d
jle    1400 <main+0x260>
mov    %r15d,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rcx,1),%edx
cmp    (%r12,%rcx,1),%dl
jne    12b8 <main+0x118>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12e0 <main+0x140>
test   %r15d,%r15d
jle    1400 <main+0x260>
cmp    $0x8,%r15d
jae    130b <main+0x16b>
xor    %ecx,%ecx
jmp    13f2 <main+0x252>
cmp    $0x20,%r15d
jae    1318 <main+0x178>
xor    %ecx,%ecx
jmp    13c8 <main+0x228>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1391 <main+0x1f1>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
add    %rbx,%rbp
add    $0x30,%rbp
xor    %edx,%edx
pcmpeqd %xmm0,%xmm0
movdqu -0x30(%rbp,%rdx,1),%xmm1
movdqu -0x20(%rbp,%rdx,1),%xmm2
movdqu -0x10(%rbp,%rdx,1),%xmm3
movdqu 0x0(%rbp,%rdx,1),%xmm4
psubb  %xmm0,%xmm1
psubb  %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbp,%rdx,1)
movdqu %xmm2,-0x20(%rbp,%rdx,1)
psubb  %xmm0,%xmm3
psubb  %xmm0,%xmm4
movdqu %xmm3,-0x10(%rbp,%rdx,1)
movdqu %xmm4,0x0(%rbp,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1345 <main+0x1a5>
jmp    1393 <main+0x1f3>
xor    %edx,%edx
test   $0x1,%sil
je     13bf <main+0x21f>
movdqu (%r12,%rdx,1),%xmm0
movdqu 0x10(%r12,%rdx,1),%xmm1
pcmpeqd %xmm2,%xmm2
psubb  %xmm2,%xmm0
psubb  %xmm2,%xmm1
movdqu %xmm0,(%r12,%rdx,1)
movdqu %xmm1,0x10(%r12,%rdx,1)
cmp    %rax,%rcx
je     1400 <main+0x260>
test   $0x18,%al
je     13f2 <main+0x252>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
pcmpeqd %xmm0,%xmm0
movq   (%r12,%rdx,1),%xmm1
psubb  %xmm0,%xmm1
movq   %xmm1,(%r12,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    13d4 <main+0x234>
cmp    %rax,%rcx
je     1400 <main+0x260>
addb   $0x1,(%r12,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13f2 <main+0x252>
mov    %r15d,%edi
call   1080 <malloc@plt>
test   %rax,%rax
je     12b8 <main+0x118>
mov    %rax,%r12
mov    0x4(%rsp),%ebx
mov    %ebx,%edi
mov    %rax,%rsi
mov    %r15d,%edx
call   1060 <read@plt>
cmp    %r15d,%eax
jne    12b8 <main+0x118>
test   %r15d,%r15d
jle    1451 <main+0x2b1>
mov    %r15d,%eax
xor    %ecx,%ecx
movzbl 0x0(%r13,%rcx,1),%edx
cmp    (%r12,%rcx,1),%dl
jne    12b8 <main+0x118>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1438 <main+0x298>
mov    %ebx,%edi
call   1050 <close@plt>
xor    %r14d,%r14d
jmp    12b8 <main+0x118>

LLVM IR (-O0):
@.str = [14 x i8] c"conftest.mmap\00"
@O_RDWR = global i32 0
@PROT_READ = global i32 0
@PROT_WRITE = global i32 0
@MAP_PRIVATE = global i32 0
@MAP_FIXED = global i32 0
define i32 @main() {
%1 = alloca i32
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i32 0, i32* %1
%8 = call i32 (...) @getpagesize()
store i32 %8, i32* %6
%9 = load i32, i32* %6
%10 = call i64 @malloc(i32 %9)
%11 = inttoptr i64 %10 to i8*
store i8* %11, i8** %2
%12 = load i8*, i8** %2
%13 = icmp ne i8* %12, null
br i1 %13, label %15, label %14
14: ; preds = %0
store i32 1, i32* %1
br label %175
15: ; preds = %0
store i32 0, i32* %5
br label %16
16: ; preds = %26, %15
%17 = load i32, i32* %5
%18 = load i32, i32* %6
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %29
20: ; preds = %16
%21 = call signext i8 (...) @rand()
%22 = load i8*, i8** %2
%23 = load i32, i32* %5
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
store i8 %21, i8* %25
br label %26
26: ; preds = %20
%27 = load i32, i32* %5
%28 = add nsw i32 %27, 1
store i32 %28, i32* %5
br label %16
29: ; preds = %16
%30 = call i32 @umask(i32 0)
%31 = call i32 @creat(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 384)
store i32 %31, i32* %7
%32 = load i32, i32* %7
%33 = icmp slt i32 %32, 0
br i1 %33, label %34, label %35
34: ; preds = %29
store i32 1, i32* %1
br label %175
35: ; preds = %29
%36 = load i32, i32* %7
%37 = load i8*, i8** %2
%38 = load i32, i32* %6
%39 = call i32 @write(i32 %36, i8* %37, i32 %38)
%40 = load i32, i32* %6
%41 = icmp ne i32 %39, %40
br i1 %41, label %42, label %43
42: ; preds = %35
store i32 1, i32* %1
br label %175
43: ; preds = %35
%44 = load i32, i32* %7
%45 = call i32 @close(i32 %44)
%46 = load i32, i32* @O_RDWR
%47 = call i32 @open(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 %46)
store i32 %47, i32* %7
%48 = load i32, i32* %7
%49 = icmp slt i32 %48, 0
br i1 %49, label %50, label %51
50: ; preds = %43
store i32 1, i32* %1
br label %175
51: ; preds = %43
%52 = load i32, i32* %6
%53 = mul nsw i32 2, %52
%54 = call i64 @malloc(i32 %53)
%55 = inttoptr i64 %54 to i8*
store i8* %55, i8** %3
%56 = load i8*, i8** %3
%57 = icmp ne i8* %56, null
br i1 %57, label %59, label %58
58: ; preds = %51
store i32 1, i32* %1
br label %175
59: ; preds = %51
%60 = load i32, i32* %6
%61 = sext i32 %60 to i64
%62 = load i8*, i8** %3
%63 = ptrtoint i8* %62 to i64
%64 = load i32, i32* %6
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = and i64 %63, %66
%68 = sub nsw i64 %61, %67
%69 = load i32, i32* %6
%70 = sub nsw i32 %69, 1
%71 = sext i32 %70 to i64
%72 = and i64 %68, %71
%73 = load i8*, i8** %3
%74 = getelementptr inbounds i8, i8* %73, i64 %72
store i8* %74, i8** %3
%75 = load i8*, i8** %3
%76 = load i8*, i8** %3
%77 = load i32, i32* %6
%78 = load i32, i32* @PROT_READ
%79 = load i32, i32* @PROT_WRITE
%80 = or i32 %78, %79
%81 = load i32, i32* @MAP_PRIVATE
%82 = load i32, i32* @MAP_FIXED
%83 = or i32 %81, %82
%84 = load i32, i32* %7
%85 = call i8* @mmap(i8* %76, i32 %77, i32 %80, i32 %83, i32 %84, i64 0)
%86 = icmp ne i8* %75, %85
br i1 %86, label %87, label %88
87: ; preds = %59
store i32 1, i32* %1
br label %175
88: ; preds = %59
store i32 0, i32* %5
br label %89
89: ; preds = %109, %88
%90 = load i32, i32* %5
%91 = load i32, i32* %6
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %112
93: ; preds = %89
%94 = load i8*, i8** %2
%95 = load i32, i32* %5
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %94, i64 %96
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = load i8*, i8** %3
%101 = load i32, i32* %5
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %100, i64 %102
%104 = load i8, i8* %103
%105 = sext i8 %104 to i32
%106 = icmp ne i32 %99, %105
br i1 %106, label %107, label %108
107: ; preds = %93
store i32 1, i32* %1
br label %175
108: ; preds = %93
br label %109
109: ; preds = %108
%110 = load i32, i32* %5
%111 = add nsw i32 %110, 1
store i32 %111, i32* %5
br label %89
112: ; preds = %89
store i32 0, i32* %5
br label %113
113: ; preds = %130, %112
%114 = load i32, i32* %5
%115 = load i32, i32* %6
%116 = icmp slt i32 %114, %115
br i1 %116, label %117, label %133
117: ; preds = %113
%118 = load i8*, i8** %3
%119 = load i32, i32* %5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i8, i8* %118, i64 %120
%122 = load i8, i8* %121
%123 = sext i8 %122 to i32
%124 = add nsw i32 %123, 1
%125 = trunc i32 %124 to i8
%126 = load i8*, i8** %3
%127 = load i32, i32* %5
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
store i8 %125, i8* %129
br label %130
130: ; preds = %117
%131 = load i32, i32* %5
%132 = add nsw i32 %131, 1
store i32 %132, i32* %5
br label %113
133: ; preds = %113
%134 = load i32, i32* %6
%135 = call i64 @malloc(i32 %134)
%136 = inttoptr i64 %135 to i8*
store i8* %136, i8** %4
%137 = load i8*, i8** %4
%138 = icmp ne i8* %137, null
br i1 %138, label %140, label %139
139: ; preds = %133
store i32 1, i32* %1
br label %175
140: ; preds = %133
%141 = load i32, i32* %7
%142 = load i8*, i8** %4
%143 = load i32, i32* %6
%144 = call i32 @read(i32 %141, i8* %142, i32 %143)
%145 = load i32, i32* %6
%146 = icmp ne i32 %144, %145
br i1 %146, label %147, label %148
147: ; preds = %140
store i32 1, i32* %1
br label %175
148: ; preds = %140
store i32 0, i32* %5
br label %149
149: ; preds = %169, %148
%150 = load i32, i32* %5
%151 = load i32, i32* %6
%152 = icmp slt i32 %150, %151
br i1 %152, label %153, label %172
153: ; preds = %149
%154 = load i8*, i8** %2
%155 = load i32, i32* %5
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %154, i64 %156
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = load i8*, i8** %4
%161 = load i32, i32* %5
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8, i8* %160, i64 %162
%164 = load i8, i8* %163
%165 = sext i8 %164 to i32
%166 = icmp ne i32 %159, %165
br i1 %166, label %167, label %168
167: ; preds = %153
store i32 1, i32* %1
br label %175
168: ; preds = %153
br label %169
169: ; preds = %168
%170 = load i32, i32* %5
%171 = add nsw i32 %170, 1
store i32 %171, i32* %5
br label %149
172: ; preds = %149
%173 = load i32, i32* %7
%174 = call i32 @close(i32 %173)
store i32 0, i32* %1
br label %175
175: ; preds = %172, %167, %147, %139, %107, %87, %58, %50, %42, %34, %14
%176 = load i32, i32* %1
ret i32 %176
}

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