#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*/ SENNA_free(char *);
char *SENNA_malloc(int, int);
void buffer_reverse_memory(void *ptr_, int block_size, int n_blocks) {
  char *ptr;
  char *ptrr;
  char *ptrw;
  int i, j;
  char *buffer_block;
  if (block_size == 1)
    return;
  ptr = (char *)ptr_;
  buffer_block = SENNA_malloc(sizeof(char), block_size);
  for (i = 0; i < n_blocks; i++) {
    ptrr = ptr + ((i + 1) * block_size);
    ptrw = buffer_block;
    for (j = 0; j < block_size; j++) {
      ptrr--;
      *ptrw++ = *ptrr;
    }
    ptrr = buffer_block;
    ptrw = ptr + (i * block_size);
    for (j = 0; j < block_size; j++)
      *ptrw++ = *ptrr++;
  }
  SENNA_free(buffer_block);
}


x86 assembly (clang, -O0):
<buffer_reverse_memory>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cmpl   $0x1,-0xc(%rbp)
jne    1141 <buffer_reverse_memory+0x21>
jmp    124d <buffer_reverse_memory+0x12d>
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1040 <SENNA_malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1244 <buffer_reverse_memory+0x124>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11d1 <buffer_reverse_memory+0xb1>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1194 <buffer_reverse_memory+0x74>
mov    -0x38(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1231 <buffer_reverse_memory+0x111>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11f5 <buffer_reverse_memory+0xd5>
jmp    1236 <buffer_reverse_memory+0x116>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1161 <buffer_reverse_memory+0x41>
mov    -0x38(%rbp),%rdi
call   1030 <SENNA_free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<buffer_reverse_memory>:
cmp    $0x1,%esi
jne    1126 <buffer_reverse_memory+0x6>
ret
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%ebp
mov    %esi,%ebx
mov    %rdi,0x30(%rsp)
mov    $0x1,%edi
call   1040 <SENNA_malloc@plt>
test   %ebp,%ebp
jle    16c5 <buffer_reverse_memory+0x5a5>
movslq %ebx,%r12
mov    %ebp,%ecx
mov    %rcx,0x98(%rsp)
lea    -0x1(%rbx),%ecx
lea    0x1(%rcx),%rdx
lea    0x1(%rax,%rcx,1),%rsi
mov    %rsi,0x58(%rsp)
mov    %rcx,0x18(%rsp)
not    %rcx
add    %r12,%rcx
mov    %rcx,0x90(%rsp)
mov    %rdx,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,0x78(%rsp)
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %rsi,%rdi
neg    %rdi
mov    %rdi,0x40(%rsp)
movabs $0x1ffffffe0,%rdi
or     $0x18,%rdi
and    %rdx,%rdi
mov    %rdi,%rbp
neg    %rbp
mov    %rbp,0x88(%rsp)
mov    %ecx,%ebp
and    $0x3,%ebp
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x60(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
and    $0xfffffffffffffff8,%rdx
neg    %rdx
mov    %rdx,0x80(%rsp)
mov    %rbp,0x70(%rsp)
shl    $0x5,%rbp
mov    %rbp,0x68(%rsp)
pxor   %xmm0,%xmm0
mov    %rsi,0x10(%rsp)
lea    (%rax,%rsi,1),%rcx
mov    %rcx,0x38(%rsp)
mov    %rdi,0x20(%rsp)
lea    (%rax,%rdi,1),%rcx
mov    %rcx,0x50(%rsp)
lea    0x10(%rax),%rcx
mov    %rcx,0x48(%rsp)
mov    0x30(%rsp),%r14
lea    -0x10(%r12,%r14,1),%r11
lea    (%r12,%r14,1),%r8
add    $0xfffffffffffffff8,%r8
lea    0x70(%r14),%r10
lea    0x10(%r14),%r15
xor    %r13d,%r13d
mov    %rbx,0x28(%rsp)
jmp    126d <buffer_reverse_memory+0x14d>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r12,%r11
add    %r12,%r8
add    %r12,%r10
add    %r12,%r15
add    %r12,%r14
cmp    0x98(%rsp),%r13
je     16c5 <buffer_reverse_memory+0x5a5>
mov    %r13,%rdx
add    $0x1,%r13
test   %ebx,%ebx
jle    1250 <buffer_reverse_memory+0x130>
imul   %r12,%rdx
mov    %r13,0xa0(%rsp)
mov    %r13,%r9
imul   %r12,%r9
mov    0x30(%rsp),%rsi
add    %rsi,%r9
xor    %r13d,%r13d
cmpl   $0x7,0x18(%rsp)
jb     12c6 <buffer_reverse_memory+0x1a6>
lea    (%rdx,%r12,1),%rcx
add    %rsi,%rcx
cmp    %rcx,%rax
jae    1444 <buffer_reverse_memory+0x324>
mov    0x90(%rsp),%rcx
add    %rdx,%rcx
add    %rsi,%rcx
cmp    0x58(%rsp),%rcx
jae    1444 <buffer_reverse_memory+0x324>
mov    %rax,%rbp
mov    %ebx,%esi
sub    %r13d,%esi
mov    %r13d,%edi
not    %edi
add    %ebx,%edi
and    $0x7,%esi
je     1300 <buffer_reverse_memory+0x1e0>
neg    %esi
xor    %ecx,%ecx
xchg   %ax,%ax
movzbl -0x1(%r9,%rcx,1),%ebx
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rcx
cmp    %ecx,%esi
jne    12e0 <buffer_reverse_memory+0x1c0>
add    %rcx,%r9
sub    %ecx,%r13d
mov    0x28(%rsp),%rbx
cmp    $0x7,%edi
jb     1363 <buffer_reverse_memory+0x243>
add    $0xffffffffffffffff,%r9
mov    %ebx,%esi
sub    %r13d,%esi
xor    %edi,%edi
movzbl (%r9),%ecx
mov    %cl,0x0(%rbp,%rdi,1)
movzbl -0x1(%r9),%ecx
mov    %cl,0x1(%rbp,%rdi,1)
movzbl -0x2(%r9),%ecx
mov    %cl,0x2(%rbp,%rdi,1)
movzbl -0x3(%r9),%ecx
mov    %cl,0x3(%rbp,%rdi,1)
movzbl -0x4(%r9),%ecx
mov    %cl,0x4(%rbp,%rdi,1)
movzbl -0x5(%r9),%ecx
mov    %cl,0x5(%rbp,%rdi,1)
movzbl -0x6(%r9),%ecx
mov    %cl,0x6(%rbp,%rdi,1)
movzbl -0x7(%r9),%ecx
mov    %cl,0x7(%rbp,%rdi,1)
add    $0xfffffffffffffff8,%r9
add    $0x8,%rdi
cmp    %edi,%esi
jne    1310 <buffer_reverse_memory+0x1f0>
test   %ebx,%ebx
mov    0xa0(%rsp),%r13
jle    1250 <buffer_reverse_memory+0x130>
mov    0x30(%rsp),%rcx
lea    (%rcx,%rdx,1),%rbp
xor    %r9d,%r9d
cmpl   $0x7,0x18(%rsp)
jb     13a2 <buffer_reverse_memory+0x282>
cmp    0x58(%rsp),%rbp
jae    1457 <buffer_reverse_memory+0x337>
add    0x8(%rsp),%rdx
add    %rcx,%rdx
cmp    %rdx,%rax
jae    1457 <buffer_reverse_memory+0x337>
mov    %rax,%rdx
mov    %ebx,%esi
sub    %r9d,%esi
mov    %r9d,%edi
not    %edi
add    %ebx,%edi
and    $0x7,%esi
je     13de <buffer_reverse_memory+0x2be>
neg    %esi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
add    $0x1,%rdx
mov    %bl,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rcx
cmp    %ecx,%esi
jne    13c0 <buffer_reverse_memory+0x2a0>
sub    %ecx,%r9d
mov    0x28(%rsp),%rbx
cmp    $0x7,%edi
jb     1250 <buffer_reverse_memory+0x130>
mov    %ebx,%esi
sub    %r9d,%esi
xor    %edi,%edi
xchg   %ax,%ax
movzbl (%rdx,%rdi,1),%ecx
mov    %cl,0x0(%rbp,%rdi,1)
movzbl 0x1(%rdx,%rdi,1),%ecx
mov    %cl,0x1(%rbp,%rdi,1)
movzbl 0x2(%rdx,%rdi,1),%ecx
mov    %cl,0x2(%rbp,%rdi,1)
movzbl 0x3(%rdx,%rdi,1),%ecx
mov    %cl,0x3(%rbp,%rdi,1)
movzbl 0x4(%rdx,%rdi,1),%ecx
mov    %cl,0x4(%rbp,%rdi,1)
movzbl 0x5(%rdx,%rdi,1),%ecx
mov    %cl,0x5(%rbp,%rdi,1)
movzbl 0x6(%rdx,%rdi,1),%ecx
mov    %cl,0x6(%rbp,%rdi,1)
movzbl 0x7(%rdx,%rdi,1),%ecx
mov    %cl,0x7(%rbp,%rdi,1)
add    $0x8,%rdi
cmp    %edi,%esi
jne    13f0 <buffer_reverse_memory+0x2d0>
jmp    1250 <buffer_reverse_memory+0x130>
cmpl   $0x1f,0x18(%rsp)
jae    1469 <buffer_reverse_memory+0x349>
xor    %esi,%esi
mov    0x20(%rsp),%rdi
jmp    1529 <buffer_reverse_memory+0x409>
cmpl   $0x1f,0x18(%rsp)
jae    1586 <buffer_reverse_memory+0x466>
xor    %ecx,%ecx
jmp    165b <buffer_reverse_memory+0x53b>
xor    %edi,%edi
mov    0x48(%rsp),%rbx
mov    0x40(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%r11,%rdi,1),%xmm1
movdqu (%r11,%rdi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rbx)
movdqu %xmm1,(%rbx)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rdi
cmp    %rdi,%rcx
jne    1480 <buffer_reverse_memory+0x360>
mov    0x10(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
mov    0x28(%rsp),%rbx
je     1363 <buffer_reverse_memory+0x243>
mov    0x10(%rsp),%rsi
testb  $0x18,0x8(%rsp)
mov    0x20(%rsp),%rdi
je     1699 <buffer_reverse_memory+0x579>
add    0x88(%rsp),%r9
lea    (%rax,%rsi,1),%rcx
neg    %rsi
mov    0x80(%rsp),%rbp
movq   (%r8,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rcx)
add    $0x8,%rcx
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rbp
jne    1540 <buffer_reverse_memory+0x420>
mov    %edi,%r13d
mov    0x50(%rsp),%rbp
cmp    %rdi,0x8(%rsp)
jne    12c9 <buffer_reverse_memory+0x1a9>
jmp    1363 <buffer_reverse_memory+0x243>
cmpq   $0x60,0x78(%rsp)
mov    0x68(%rsp),%rdi
jae    1597 <buffer_reverse_memory+0x477>
xor    %edx,%edx
jmp    1604 <buffer_reverse_memory+0x4e4>
mov    0x60(%rsp),%rsi
xor    %edx,%edx
xchg   %ax,%ax
movups (%rax,%rdx,1),%xmm1
movups 0x10(%rax,%rdx,1),%xmm2
movups %xmm1,-0x70(%r10,%rdx,1)
movups %xmm2,-0x60(%r10,%rdx,1)
movups 0x20(%rax,%rdx,1),%xmm1
movups 0x30(%rax,%rdx,1),%xmm2
movups %xmm1,-0x50(%r10,%rdx,1)
movups %xmm2,-0x40(%r10,%rdx,1)
movups 0x40(%rax,%rdx,1),%xmm1
movups 0x50(%rax,%rdx,1),%xmm2
movups %xmm1,-0x30(%r10,%rdx,1)
movups %xmm2,-0x20(%r10,%rdx,1)
movdqu 0x60(%rax,%rdx,1),%xmm1
movdqu 0x70(%rax,%rdx,1),%xmm2
movdqu %xmm1,-0x10(%r10,%rdx,1)
movdqu %xmm2,(%r10,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    15a0 <buffer_reverse_memory+0x480>
cmpq   $0x0,0x70(%rsp)
je     163f <buffer_reverse_memory+0x51f>
lea    (%r15,%rdx,1),%rcx
add    0x48(%rsp),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rsi,1),%xmm1
movdqu (%rdx,%rsi,1),%xmm2
movdqu %xmm1,-0x10(%rcx,%rsi,1)
movdqu %xmm2,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    1620 <buffer_reverse_memory+0x500>
mov    0x10(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
je     1250 <buffer_reverse_memory+0x130>
mov    0x10(%rsp),%rcx
testb  $0x18,0x8(%rsp)
je     16b0 <buffer_reverse_memory+0x590>
mov    0x20(%rsp),%rsi
add    %rsi,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rcx,1),%rdx
mov    %rdx,(%r14,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1670 <buffer_reverse_memory+0x550>
mov    0x50(%rsp),%rdx
mov    %esi,%r9d
cmp    %rsi,0x8(%rsp)
je     1250 <buffer_reverse_memory+0x130>
jmp    13a5 <buffer_reverse_memory+0x285>
add    0x40(%rsp),%r9
mov    0x10(%rsp),%rcx
mov    %ecx,%r13d
mov    0x38(%rsp),%rbp
jmp    12c9 <buffer_reverse_memory+0x1a9>
mov    0x10(%rsp),%rcx
add    %rcx,%rbp
mov    0x38(%rsp),%rdx
mov    %ecx,%r9d
jmp    13a5 <buffer_reverse_memory+0x285>
mov    %rax,%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <SENNA_free@plt>

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

LLVM IR (-O2):
define void @buffer_reverse_memory(i8* nocapture %0, i32 %1, i32 %2) {
%4 = icmp eq i32 %1, 1
br i1 %4, label %333, label %5
5: ; preds = %3
%6 = tail call i8* @SENNA_malloc(i32 1, i32 %1)
%7 = icmp sgt i32 %2, 0
br i1 %7, label %8, label %331
8: ; preds = %5
%9 = icmp sgt i32 %1, 0
%10 = sext i32 %1 to i64
%11 = zext i32 %2 to i64
%12 = add i32 %1, -1
%13 = zext i32 %12 to i64
%14 = add nuw nsw i64 %13, 1
%15 = getelementptr i8, i8* %6, i64 %14
%16 = zext i32 %12 to i64
%17 = add nuw nsw i64 %16, 1
%18 = zext i32 %12 to i64
%19 = add nuw nsw i64 %18, 1
%20 = add i32 %1, -1
%21 = zext i32 %20 to i64
%22 = add nuw nsw i64 %21, 1
%23 = getelementptr i8, i8* %6, i64 %22
%24 = xor i64 %21, -1
%25 = add nsw i64 %24, %10
%26 = zext i32 %20 to i64
%27 = add nuw nsw i64 %26, 1
%28 = add i32 %1, -1
%29 = zext i32 %28 to i64
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %27, 8589934560
%32 = add nsw i64 %31, -32
%33 = lshr exact i64 %32, 5
%34 = add nuw nsw i64 %33, 1
%35 = icmp ult i32 %20, 7
%36 = icmp ult i32 %20, 31
%37 = and i64 %27, 8589934560
%38 = icmp eq i64 %27, %37
%39 = getelementptr i8, i8* %6, i64 %37
%40 = trunc i64 %37 to i32
%41 = sub nsw i64 0, %37
%42 = and i64 %27, 24
%43 = icmp eq i64 %42, 0
%44 = and i64 %30, 8589934584
%45 = sub nsw i64 0, %44
%46 = trunc i64 %44 to i32
%47 = getelementptr i8, i8* %6, i64 %44
%48 = icmp eq i64 %30, %44
%49 = icmp ult i32 %12, 7
%50 = icmp ult i32 %12, 31
%51 = and i64 %17, 8589934560
%52 = and i64 %34, 3
%53 = icmp ult i64 %32, 96
%54 = and i64 %34, 1152921504606846972
%55 = icmp eq i64 %52, 0
%56 = icmp eq i64 %17, %51
%57 = trunc i64 %51 to i32
%58 = getelementptr i8, i8* %6, i64 %51
%59 = and i64 %17, 24
%60 = icmp eq i64 %59, 0
%61 = and i64 %19, 8589934584
%62 = getelementptr i8, i8* %6, i64 %61
%63 = trunc i64 %61 to i32
%64 = icmp eq i64 %19, %61
br label %67
65: ; preds = %296, %301, %260, %275, %67, %183
%66 = icmp eq i64 %78, %11
br i1 %66, label %331, label %67
67: ; preds = %8, %65
%68 = phi i64 [ 0, %8 ], [ %78, %65 ]
%69 = mul i64 %68, %10
%70 = add i64 %25, %69
%71 = getelementptr i8, i8* %0, i64 %70
%72 = add i64 %69, %10
%73 = getelementptr i8, i8* %0, i64 %72
%74 = mul i64 %68, %10
%75 = getelementptr i8, i8* %0, i64 %74
%76 = add i64 %14, %74
%77 = getelementptr i8, i8* %0, i64 %76
%78 = add nuw nsw i64 %68, 1
br i1 %9, label %79, label %65
79: ; preds = %67
%80 = mul nsw i64 %78, %10
%81 = getelementptr inbounds i8, i8* %0, i64 %80
br i1 %35, label %128, label %82
82: ; preds = %79
%83 = icmp ult i8* %6, %73
%84 = icmp ult i8* %71, %23
%85 = and i1 %83, %84
br i1 %85, label %128, label %86
86: ; preds = %82
br i1 %36, label %111, label %87
87: ; preds = %86
%88 = getelementptr i8, i8* %81, i64 -1
br label %89
89: ; preds = %89, %87
%90 = phi i64 [ 0, %87 ], [ %106, %89 ]
%91 = sub i64 0, %90
%92 = getelementptr i8, i8* %6, i64 %90
%93 = getelementptr inbounds i8, i8* %88, i64 %91
%94 = getelementptr inbounds i8, i8* %93, i64 -15
%95 = bitcast i8* %94 to <16 x i8>*
%96 = load <16 x i8>, <16 x i8>* %95
%97 = shufflevector <16 x i8> %96, <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>
%98 = getelementptr inbounds i8, i8* %93, i64 -16
%99 = getelementptr inbounds i8, i8* %98, i64 -15
%100 = bitcast i8* %99 to <16 x i8>*
%101 = load <16 x i8>, <16 x i8>* %100
%102 = shufflevector <16 x i8> %101, <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>
%103 = bitcast i8* %92 to <16 x i8>*
store <16 x i8> %97, <16 x i8>* %103
%104 = getelementptr i8, i8* %92, i64 16
%105 = bitcast i8* %104 to <16 x i8>*
store <16 x i8> %102, <16 x i8>* %105
%106 = add nuw i64 %90, 32
%107 = icmp eq i64 %106, %37
br i1 %107, label %108, label %89
108: ; preds = %89
br i1 %38, label %183, label %109
109: ; preds = %108
%110 = getelementptr i8, i8* %81, i64 %41
br i1 %43, label %128, label %111
111: ; preds = %86, %109
%112 = phi i64 [ %37, %109 ], [ 0, %86 ]
%113 = getelementptr i8, i8* %81, i64 %45
%114 = getelementptr i8, i8* %81, i64 -1
%115 = getelementptr inbounds i8, i8* %114, i64 -7
br label %116
116: ; preds = %116, %111
%117 = phi i64 [ %112, %111 ], [ %125, %116 ]
%118 = sub i64 0, %117
%119 = getelementptr i8, i8* %6, i64 %117
%120 = getelementptr inbounds i8, i8* %115, i64 %118
%121 = bitcast i8* %120 to <8 x i8>*
%122 = load <8 x i8>, <8 x i8>* %121
%123 = shufflevector <8 x i8> %122, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%124 = bitcast i8* %119 to <8 x i8>*
store <8 x i8> %123, <8 x i8>* %124
%125 = add nuw i64 %117, 8
%126 = icmp eq i64 %125, %44
br i1 %126, label %127, label %116
127: ; preds = %116
br i1 %48, label %183, label %128
128: ; preds = %82, %79, %109, %127
%129 = phi i8* [ %81, %79 ], [ %81, %82 ], [ %110, %109 ], [ %113, %127 ]
%130 = phi i32 [ 0, %79 ], [ 0, %82 ], [ %40, %109 ], [ %46, %127 ]
%131 = phi i8* [ %6, %79 ], [ %6, %82 ], [ %39, %109 ], [ %47, %127 ]
%132 = sub i32 %1, %130
%133 = xor i32 %130, -1
%134 = add i32 %133, %1
%135 = and i32 %132, 7
%136 = icmp eq i32 %135, 0
br i1 %136, label %148, label %137
137: ; preds = %128, %137
%138 = phi i8* [ %142, %137 ], [ %129, %128 ]
%139 = phi i32 [ %145, %137 ], [ %130, %128 ]
%140 = phi i8* [ %144, %137 ], [ %131, %128 ]
%141 = phi i32 [ %146, %137 ], [ 0, %128 ]
%142 = getelementptr inbounds i8, i8* %138, i64 -1
%143 = load i8, i8* %142
%144 = getelementptr inbounds i8, i8* %140, i64 1
store i8 %143, i8* %140
%145 = add nuw nsw i32 %139, 1
%146 = add i32 %141, 1
%147 = icmp eq i32 %146, %135
br i1 %147, label %148, label %137
148: ; preds = %137, %128
%149 = phi i8* [ %129, %128 ], [ %142, %137 ]
%150 = phi i32 [ %130, %128 ], [ %145, %137 ]
%151 = phi i8* [ %131, %128 ], [ %144, %137 ]
%152 = icmp ult i32 %134, 7
br i1 %152, label %183, label %153
153: ; preds = %148, %153
%154 = phi i8* [ %178, %153 ], [ %149, %148 ]
%155 = phi i32 [ %181, %153 ], [ %150, %148 ]
%156 = phi i8* [ %180, %153 ], [ %151, %148 ]
%157 = getelementptr inbounds i8, i8* %154, i64 -1
%158 = load i8, i8* %157
%159 = getelementptr inbounds i8, i8* %156, i64 1
store i8 %158, i8* %156
%160 = getelementptr inbounds i8, i8* %154, i64 -2
%161 = load i8, i8* %160
%162 = getelementptr inbounds i8, i8* %156, i64 2
store i8 %161, i8* %159
%163 = getelementptr inbounds i8, i8* %154, i64 -3
%164 = load i8, i8* %163
%165 = getelementptr inbounds i8, i8* %156, i64 3
store i8 %164, i8* %162
%166 = getelementptr inbounds i8, i8* %154, i64 -4
%167 = load i8, i8* %166
%168 = getelementptr inbounds i8, i8* %156, i64 4
store i8 %167, i8* %165
%169 = getelementptr inbounds i8, i8* %154, i64 -5
%170 = load i8, i8* %169
%171 = getelementptr inbounds i8, i8* %156, i64 5
store i8 %170, i8* %168
%172 = getelementptr inbounds i8, i8* %154, i64 -6
%173 = load i8, i8* %172
%174 = getelementptr inbounds i8, i8* %156, i64 6
store i8 %173, i8* %171
%175 = getelementptr inbounds i8, i8* %154, i64 -7
%176 = load i8, i8* %175
%177 = getelementptr inbounds i8, i8* %156, i64 7
store i8 %176, i8* %174
%178 = getelementptr inbounds i8, i8* %154, i64 -8
%179 = load i8, i8* %178
%180 = getelementptr inbounds i8, i8* %156, i64 8
store i8 %179, i8* %177
%181 = add nuw nsw i32 %155, 8
%182 = icmp eq i32 %181, %1
br i1 %182, label %183, label %153
183: ; preds = %148, %153, %127, %108
br i1 %9, label %184, label %65
184: ; preds = %183
%185 = mul nsw i64 %68, %10
%186 = getelementptr inbounds i8, i8* %0, i64 %185
br i1 %49, label %276, label %187
187: ; preds = %184
%188 = icmp ult i8* %75, %15
%189 = icmp ult i8* %6, %77
%190 = and i1 %188, %189
br i1 %190, label %276, label %191
191: ; preds = %187
br i1 %50, label %263, label %192
192: ; preds = %191
br i1 %53, label %242, label %193
193: ; preds = %192, %193
%194 = phi i64 [ %239, %193 ], [ 0, %192 ]
%195 = phi i64 [ %240, %193 ], [ 0, %192 ]
%196 = getelementptr i8, i8* %6, i64 %194
%197 = getelementptr i8, i8* %186, i64 %194
%198 = bitcast i8* %196 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr i8, i8* %196, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = bitcast i8* %197 to <16 x i8>*
store <16 x i8> %199, <16 x i8>* %203
%204 = getelementptr i8, i8* %197, i64 16
%205 = bitcast i8* %204 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %205
%206 = or i64 %194, 32
%207 = getelementptr i8, i8* %6, i64 %206
%208 = getelementptr i8, i8* %186, i64 %206
%209 = bitcast i8* %207 to <16 x i8>*
%210 = load <16 x i8>, <16 x i8>* %209
%211 = getelementptr i8, i8* %207, i64 16
%212 = bitcast i8* %211 to <16 x i8>*
%213 = load <16 x i8>, <16 x i8>* %212
%214 = bitcast i8* %208 to <16 x i8>*
store <16 x i8> %210, <16 x i8>* %214
%215 = getelementptr i8, i8* %208, i64 16
%216 = bitcast i8* %215 to <16 x i8>*
store <16 x i8> %213, <16 x i8>* %216
%217 = or i64 %194, 64
%218 = getelementptr i8, i8* %6, i64 %217
%219 = getelementptr i8, i8* %186, i64 %217
%220 = bitcast i8* %218 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = getelementptr i8, i8* %218, i64 16
%223 = bitcast i8* %222 to <16 x i8>*
%224 = load <16 x i8>, <16 x i8>* %223
%225 = bitcast i8* %219 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %225
%226 = getelementptr i8, i8* %219, i64 16
%227 = bitcast i8* %226 to <16 x i8>*
store <16 x i8> %224, <16 x i8>* %227
%228 = or i64 %194, 96
%229 = getelementptr i8, i8* %6, i64 %228
%230 = getelementptr i8, i8* %186, i64 %228
%231 = bitcast i8* %229 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = getelementptr i8, i8* %229, i64 16
%234 = bitcast i8* %233 to <16 x i8>*
%235 = load <16 x i8>, <16 x i8>* %234
%236 = bitcast i8* %230 to <16 x i8>*
store <16 x i8> %232, <16 x i8>* %236
%237 = getelementptr i8, i8* %230, i64 16
%238 = bitcast i8* %237 to <16 x i8>*
store <16 x i8> %235, <16 x i8>* %238
%239 = add nuw i64 %194, 128
%240 = add i64 %195, 4
%241 = icmp eq i64 %240, %54
br i1 %241, label %242, label %193
242: ; preds = %193, %192
%243 = phi i64 [ 0, %192 ], [ %239, %193 ]
br i1 %55, label %260, label %244
244: ; preds = %242, %244
%245 = phi i64 [ %257, %244 ], [ %243, %242 ]
%246 = phi i64 [ %258, %244 ], [ 0, %242 ]
%247 = getelementptr i8, i8* %6, i64 %245
%248 = getelementptr i8, i8* %186, i64 %245
%249 = bitcast i8* %247 to <16 x i8>*
%250 = load <16 x i8>, <16 x i8>* %249
%251 = getelementptr i8, i8* %247, i64 16
%252 = bitcast i8* %251 to <16 x i8>*
%253 = load <16 x i8>, <16 x i8>* %252
%254 = bitcast i8* %248 to <16 x i8>*
store <16 x i8> %250, <16 x i8>* %254
%255 = getelementptr i8, i8* %248, i64 16
%256 = bitcast i8* %255 to <16 x i8>*
store <16 x i8> %253, <16 x i8>* %256
%257 = add nuw i64 %245, 32
%258 = add i64 %246, 1
%259 = icmp eq i64 %258, %52
br i1 %259, label %260, label %244
260: ; preds = %244, %242
br i1 %56, label %65, label %261
261: ; preds = %260
%262 = getelementptr i8, i8* %186, i64 %51
br i1 %60, label %276, label %263
263: ; preds = %191, %261
%264 = phi i64 [ %51, %261 ], [ 0, %191 ]
%265 = getelementptr i8, i8* %186, i64 %61
br label %266
266: ; preds = %266, %263
%267 = phi i64 [ %264, %263 ], [ %273, %266 ]
%268 = getelementptr i8, i8* %6, i64 %267
%269 = getelementptr i8, i8* %186, i64 %267
%270 = bitcast i8* %268 to <8 x i8>*
%271 = load <8 x i8>, <8 x i8>* %270
%272 = bitcast i8* %269 to <8 x i8>*
store <8 x i8> %271, <8 x i8>* %272
%273 = add nuw i64 %267, 8
%274 = icmp eq i64 %273, %61
br i1 %274, label %275, label %266
275: ; preds = %266
br i1 %64, label %65, label %276
276: ; preds = %187, %184, %261, %275
%277 = phi i8* [ %6, %184 ], [ %6, %187 ], [ %58, %261 ], [ %62, %275 ]
%278 = phi i32 [ 0, %184 ], [ 0, %187 ], [ %57, %261 ], [ %63, %275 ]
%279 = phi i8* [ %186, %184 ], [ %186, %187 ], [ %262, %261 ], [ %265, %275 ]
%280 = sub i32 %1, %278
%281 = xor i32 %278, -1
%282 = add i32 %281, %1
%283 = and i32 %280, 7
%284 = icmp eq i32 %283, 0
br i1 %284, label %296, label %285
285: ; preds = %276, %285
%286 = phi i8* [ %290, %285 ], [ %277, %276 ]
%287 = phi i32 [ %293, %285 ], [ %278, %276 ]
%288 = phi i8* [ %292, %285 ], [ %279, %276 ]
%289 = phi i32 [ %294, %285 ], [ 0, %276 ]
%290 = getelementptr inbounds i8, i8* %286, i64 1
%291 = load i8, i8* %286
%292 = getelementptr inbounds i8, i8* %288, i64 1
store i8 %291, i8* %288
%293 = add nuw nsw i32 %287, 1
%294 = add i32 %289, 1
%295 = icmp eq i32 %294, %283
br i1 %295, label %296, label %285
296: ; preds = %285, %276
%297 = phi i8* [ %277, %276 ], [ %290, %285 ]
%298 = phi i32 [ %278, %276 ], [ %293, %285 ]
%299 = phi i8* [ %279, %276 ], [ %292, %285 ]
%300 = icmp ult i32 %282, 7
br i1 %300, label %65, label %301
301: ; preds = %296, %301
%302 = phi i8* [ %326, %301 ], [ %297, %296 ]
%303 = phi i32 [ %329, %301 ], [ %298, %296 ]
%304 = phi i8* [ %328, %301 ], [ %299, %296 ]
%305 = getelementptr inbounds i8, i8* %302, i64 1
%306 = load i8, i8* %302
%307 = getelementptr inbounds i8, i8* %304, i64 1
store i8 %306, i8* %304
%308 = getelementptr inbounds i8, i8* %302, i64 2
%309 = load i8, i8* %305
%310 = getelementptr inbounds i8, i8* %304, i64 2
store i8 %309, i8* %307
%311 = getelementptr inbounds i8, i8* %302, i64 3
%312 = load i8, i8* %308
%313 = getelementptr inbounds i8, i8* %304, i64 3
store i8 %312, i8* %310
%314 = getelementptr inbounds i8, i8* %302, i64 4
%315 = load i8, i8* %311
%316 = getelementptr inbounds i8, i8* %304, i64 4
store i8 %315, i8* %313
%317 = getelementptr inbounds i8, i8* %302, i64 5
%318 = load i8, i8* %314
%319 = getelementptr inbounds i8, i8* %304, i64 5
store i8 %318, i8* %316
%320 = getelementptr inbounds i8, i8* %302, i64 6
%321 = load i8, i8* %317
%322 = getelementptr inbounds i8, i8* %304, i64 6
store i8 %321, i8* %319
%323 = getelementptr inbounds i8, i8* %302, i64 7
%324 = load i8, i8* %320
%325 = getelementptr inbounds i8, i8* %304, i64 7
store i8 %324, i8* %322
%326 = getelementptr inbounds i8, i8* %302, i64 8
%327 = load i8, i8* %323
%328 = getelementptr inbounds i8, i8* %304, i64 8
store i8 %327, i8* %325
%329 = add nuw nsw i32 %303, 8
%330 = icmp eq i32 %329, %1
br i1 %330, label %65, label %301
331: ; preds = %65, %5
%332 = tail call i32 @SENNA_free(i8* %6)
br label %333
333: ; preds = %3, %331
ret void
}