#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 */
void init_data(char *tx_buf, char *rx_buf, size_t tx_buf_size,
               size_t rx_buf_size) {
  size_t i;
  int *transmit_buffer, *receive_buffer;
  transmit_buffer = (int *)tx_buf;
  receive_buffer = (int *)rx_buf;
  for (i = 0; i < tx_buf_size / sizeof(int); i++) {
    transmit_buffer[i] = ((int)(0x1234ACDE ^ (i)));
  }
  for (i = 0; i < tx_buf_size % sizeof(int); i++) {
    tx_buf[i] = ((int)(0x1234ACDE ^ (i + tx_buf_size / sizeof(int))));
  }
  for (i = 0; i < rx_buf_size / sizeof(int); i++) {
    receive_buffer[i] = ((int)(0x1234ACDE ^ (i + tx_buf_size)));
  }
  for (i = 0; i < rx_buf_size % sizeof(int); i++) {
    rx_buf[i] =
        ((int)(0x1234ACDE ^ (i + tx_buf_size + rx_buf_size / sizeof(int))));
  }
  return;
}


x86 assembly (clang, -O0):
<init_data>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    1169 <init_data+0x69>
mov    -0x28(%rbp),%rax
xor    $0x1234acde,%rax
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    112c <init_data+0x2c>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
and    $0x3,%rcx
cmp    %rcx,%rax
jae    11b9 <init_data+0xb9>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
add    %rcx,%rax
xor    $0x1234acde,%rax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1171 <init_data+0x71>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    1202 <init_data+0x102>
mov    -0x28(%rbp),%rax
add    -0x18(%rbp),%rax
xor    $0x1234acde,%rax
mov    %eax,%edx
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11c1 <init_data+0xc1>
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
and    $0x3,%rcx
cmp    %rcx,%rax
jae    1256 <init_data+0x156>
mov    -0x28(%rbp),%rax
add    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
add    %rcx,%rax
xor    $0x1234acde,%rax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    120a <init_data+0x10a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_data>:
push   %rbx
mov    %rdx,%r8
shr    $0x2,%r8
cmp    $0x4,%rdx
jb     123d <init_data+0x13d>
cmp    $0x2,%r8
mov    $0x1,%r9d
cmovae %r8,%r9
cmp    $0x8,%r9
jae    112d <init_data+0x2d>
xor    %eax,%eax
jmp    1229 <init_data+0x129>
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rbx
mov    %rbx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rbx,%rbx
je     11ed <init_data+0xed>
movabs $0x3ffffffffffffff8,%rbx
ff ff 3f
add    $0x6,%rbx
and    %r10,%rbx
movdqa 0xe9b(%rip),%xmm0
xor    %r11d,%r11d
movdqa 0xea0(%rip),%xmm1
movdqa 0xea8(%rip),%xmm2
movdqa 0xeb0(%rip),%xmm3
movdqa 0xeb8(%rip),%xmm4
movdqa 0xec0(%rip),%xmm5
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm0,%xmm7
pxor   %xmm2,%xmm7
pxor   %xmm2,%xmm6
movdqu %xmm7,(%rdi,%r11,4)
movdqu %xmm6,0x10(%rdi,%r11,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
pxor   %xmm2,%xmm6
pxor   %xmm2,%xmm7
movdqu %xmm6,0x20(%rdi,%r11,4)
movdqu %xmm7,0x30(%rdi,%r11,4)
add    $0x10,%r11
paddd  %xmm5,%xmm0
add    $0xfffffffffffffffe,%rbx
jne    1190 <init_data+0x90>
test   $0x1,%r10b
jne    11fe <init_data+0xfe>
jmp    1238 <init_data+0x138>
movdqa 0xe0b(%rip),%xmm0
xor    %r11d,%r11d
test   $0x1,%r10b
je     1238 <init_data+0x138>
movdqa 0xe0a(%rip),%xmm1
paddd  %xmm0,%xmm1
movdqa 0xe0e(%rip),%xmm2
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
movdqu %xmm0,(%rdi,%r11,4)
movdqu %xmm1,0x10(%rdi,%r11,4)
jmp    1238 <init_data+0x138>
mov    %eax,%ebx
xor    $0x1234acde,%ebx
mov    %ebx,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1229 <init_data+0x129>
mov    %rdx,%rax
and    $0x3,%rax
je     1270 <init_data+0x170>
mov    %r8d,%ebx
xor    $0xde,%bl
mov    %bl,(%rdi)
cmp    $0x1,%rax
je     1270 <init_data+0x170>
lea    0x1(%r8),%ebx
xor    $0xde,%bl
mov    %bl,0x1(%rdi)
cmp    $0x2,%rax
je     1270 <init_data+0x170>
add    $0x2,%r8b
xor    $0xde,%r8b
mov    %r8b,0x2(%rdi)
mov    %rcx,%r8
shr    $0x2,%r8
cmp    $0x4,%rcx
jb     1356 <init_data+0x256>
cmp    $0x2,%r8
mov    $0x1,%r9d
cmovae %r8,%r9
cmp    $0x8,%r9
jae    129d <init_data+0x19d>
xor    %r10d,%r10d
jmp    132f <init_data+0x22f>
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
movq   %rdx,%xmm0
pshufd $0x44,%xmm0,%xmm0
lea    0x4(%rdx),%rax
movq   %rax,%xmm1
pshufd $0x44,%xmm1,%xmm4
movdqa 0xd9c(%rip),%xmm2
movdqa 0xda4(%rip),%xmm3
xor    %ebx,%ebx
movaps 0xd4a(%rip),%xmm8
movdqa 0xda2(%rip),%xmm5
xchg   %ax,%ax
movdqa %xmm3,%xmm6
paddq  %xmm0,%xmm6
movdqa %xmm2,%xmm7
paddq  %xmm0,%xmm7
shufps $0x88,%xmm7,%xmm6
movdqa %xmm4,%xmm7
paddq  %xmm3,%xmm7
movdqa %xmm4,%xmm1
paddq  %xmm2,%xmm1
shufps $0x88,%xmm1,%xmm7
xorps  %xmm8,%xmm6
xorps  %xmm8,%xmm7
movups %xmm6,(%rsi,%rbx,4)
movups %xmm7,0x10(%rsi,%rbx,4)
add    $0x8,%rbx
paddq  %xmm5,%xmm3
paddq  %xmm5,%xmm2
cmp    %rbx,%r10
jne    12e0 <init_data+0x1e0>
cmp    %r10,%r9
je     1356 <init_data+0x256>
sub    %r10,%r9
lea    (%rsi,%r10,4),%rbx
add    %rdx,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
lea    (%r10,%rax,1),%edi
xor    $0x1234acde,%edi
mov    %edi,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1340 <init_data+0x240>
and    $0x3,%rcx
je     1387 <init_data+0x287>
add    %rdx,%r8
mov    %r8d,%eax
xor    $0xde,%al
mov    %al,(%rsi)
cmp    $0x1,%rcx
je     1387 <init_data+0x287>
lea    0x1(%r8),%eax
xor    $0xde,%al
mov    %al,0x1(%rsi)
cmp    $0x2,%rcx
je     1387 <init_data+0x287>
add    $0x2,%r8b
xor    $0xde,%r8b
mov    %r8b,0x2(%rsi)
pop    %rbx
ret

LLVM IR (-O0):
define void @init_data(i8* %0, i8* %1, i64 %2, i64 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32*
%11 = alloca i32*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
store i64 %3, i64* %8
%12 = load i8*, i8** %5
%13 = bitcast i8* %12 to i32*
store i32* %13, i32** %10
%14 = load i8*, i8** %6
%15 = bitcast i8* %14 to i32*
store i32* %15, i32** %11
store i64 0, i64* %9
br label %16
16: ; preds = %28, %4
%17 = load i64, i64* %9
%18 = load i64, i64* %7
%19 = udiv i64 %18, 4
%20 = icmp ult i64 %17, %19
br i1 %20, label %21, label %31
21: ; preds = %16
%22 = load i64, i64* %9
%23 = xor i64 305442014, %22
%24 = trunc i64 %23 to i32
%25 = load i32*, i32** %10
%26 = load i64, i64* %9
%27 = getelementptr inbounds i32, i32* %25, i64 %26
store i32 %24, i32* %27
br label %28
28: ; preds = %21
%29 = load i64, i64* %9
%30 = add i64 %29, 1
store i64 %30, i64* %9
br label %16
31: ; preds = %16
store i64 0, i64* %9
br label %32
32: ; preds = %48, %31
%33 = load i64, i64* %9
%34 = load i64, i64* %7
%35 = urem i64 %34, 4
%36 = icmp ult i64 %33, %35
br i1 %36, label %37, label %51
37: ; preds = %32
%38 = load i64, i64* %9
%39 = load i64, i64* %7
%40 = udiv i64 %39, 4
%41 = add i64 %38, %40
%42 = xor i64 305442014, %41
%43 = trunc i64 %42 to i32
%44 = trunc i32 %43 to i8
%45 = load i8*, i8** %5
%46 = load i64, i64* %9
%47 = getelementptr inbounds i8, i8* %45, i64 %46
store i8 %44, i8* %47
br label %48
48: ; preds = %37
%49 = load i64, i64* %9
%50 = add i64 %49, 1
store i64 %50, i64* %9
br label %32
51: ; preds = %32
store i64 0, i64* %9
br label %52
52: ; preds = %66, %51
%53 = load i64, i64* %9
%54 = load i64, i64* %8
%55 = udiv i64 %54, 4
%56 = icmp ult i64 %53, %55
br i1 %56, label %57, label %69
57: ; preds = %52
%58 = load i64, i64* %9
%59 = load i64, i64* %7
%60 = add i64 %58, %59
%61 = xor i64 305442014, %60
%62 = trunc i64 %61 to i32
%63 = load i32*, i32** %11
%64 = load i64, i64* %9
%65 = getelementptr inbounds i32, i32* %63, i64 %64
store i32 %62, i32* %65
br label %66
66: ; preds = %57
%67 = load i64, i64* %9
%68 = add i64 %67, 1
store i64 %68, i64* %9
br label %52
69: ; preds = %52
store i64 0, i64* %9
br label %70
70: ; preds = %88, %69
%71 = load i64, i64* %9
%72 = load i64, i64* %8
%73 = urem i64 %72, 4
%74 = icmp ult i64 %71, %73
br i1 %74, label %75, label %91
75: ; preds = %70
%76 = load i64, i64* %9
%77 = load i64, i64* %7
%78 = add i64 %76, %77
%79 = load i64, i64* %8
%80 = udiv i64 %79, 4
%81 = add i64 %78, %80
%82 = xor i64 305442014, %81
%83 = trunc i64 %82 to i32
%84 = trunc i32 %83 to i8
%85 = load i8*, i8** %6
%86 = load i64, i64* %9
%87 = getelementptr inbounds i8, i8* %85, i64 %86
store i8 %84, i8* %87
br label %88
88: ; preds = %75
%89 = load i64, i64* %9
%90 = add i64 %89, 1
store i64 %90, i64* %9
br label %70
91: ; preds = %70
ret void
}

LLVM IR (-O2):
define void @init_data(i8* nocapture writeonly %0, i8* nocapture writeonly %1, i64 %2, i64 %3) {
%5 = bitcast i8* %0 to i32*
%6 = bitcast i8* %1 to i32*
%7 = lshr i64 %2, 2
%8 = icmp ult i64 %2, 4
br i1 %8, label %61, label %9
9: ; preds = %4
%10 = call i64 @llvm.umax.i64(i64 %7, i64 1)
%11 = icmp ult i64 %10, 8
br i1 %11, label %59, label %12
12: ; preds = %9
%13 = and i64 %10, 4611686018427387896
%14 = add nsw i64 %13, -8
%15 = lshr exact i64 %14, 3
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %45, label %19
19: ; preds = %12
%20 = and i64 %16, 4611686018427387902
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %41, %21 ]
%23 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %19 ], [ %42, %21 ]
%24 = phi i64 [ 0, %19 ], [ %43, %21 ]
%25 = add <4 x i32> %23, <i32 4, i32 4, i32 4, i32 4>
%26 = xor <4 x i32> %23, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%27 = xor <4 x i32> %25, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%28 = getelementptr inbounds i32, i32* %5, i64 %22
%29 = bitcast i32* %28 to <4 x i32>*
store <4 x i32> %26, <4 x i32>* %29
%30 = getelementptr inbounds i32, i32* %28, i64 4
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %31
%32 = or i64 %22, 8
%33 = add <4 x i32> %23, <i32 8, i32 8, i32 8, i32 8>
%34 = add <4 x i32> %23, <i32 12, i32 12, i32 12, i32 12>
%35 = xor <4 x i32> %33, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%36 = xor <4 x i32> %34, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%37 = getelementptr inbounds i32, i32* %5, i64 %32
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> %35, <4 x i32>* %38
%39 = getelementptr inbounds i32, i32* %37, i64 4
%40 = bitcast i32* %39 to <4 x i32>*
store <4 x i32> %36, <4 x i32>* %40
%41 = add nuw i64 %22, 16
%42 = add <4 x i32> %23, <i32 16, i32 16, i32 16, i32 16>
%43 = add i64 %24, 2
%44 = icmp eq i64 %43, %20
br i1 %44, label %45, label %21
45: ; preds = %21, %12
%46 = phi i64 [ 0, %12 ], [ %41, %21 ]
%47 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %12 ], [ %42, %21 ]
%48 = icmp eq i64 %17, 0
br i1 %48, label %57, label %49
49: ; preds = %45
%50 = add <4 x i32> %47, <i32 4, i32 4, i32 4, i32 4>
%51 = xor <4 x i32> %47, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%52 = xor <4 x i32> %50, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%53 = getelementptr inbounds i32, i32* %5, i64 %46
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %54
%55 = getelementptr inbounds i32, i32* %53, i64 4
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %56
br label %57
57: ; preds = %45, %49
%58 = icmp eq i64 %10, %13
br i1 %58, label %61, label %59
59: ; preds = %9, %57
%60 = phi i64 [ 0, %9 ], [ %13, %57 ]
br label %64
61: ; preds = %64, %57, %4
%62 = and i64 %2, 3
%63 = icmp eq i64 %62, 0
br i1 %63, label %71, label %104
64: ; preds = %59, %64
%65 = phi i64 [ %69, %64 ], [ %60, %59 ]
%66 = trunc i64 %65 to i32
%67 = xor i32 %66, 305442014
%68 = getelementptr inbounds i32, i32* %5, i64 %65
store i32 %67, i32* %68
%69 = add nuw nsw i64 %65, 1
%70 = icmp eq i64 %69, %10
br i1 %70, label %61, label %64
71: ; preds = %104, %108, %114, %61
%72 = lshr i64 %3, 2
%73 = icmp ult i64 %3, 4
br i1 %73, label %119, label %74
74: ; preds = %71
%75 = call i64 @llvm.umax.i64(i64 %72, i64 1)
%76 = icmp ult i64 %75, 8
br i1 %76, label %102, label %77
77: ; preds = %74
%78 = and i64 %75, 4611686018427387896
%79 = insertelement <4 x i64> poison, i64 %2, i64 0
%80 = shufflevector <4 x i64> %79, <4 x i64> poison, <4 x i32> zeroinitializer
%81 = add i64 %2, 4
%82 = insertelement <4 x i64> poison, i64 %81, i64 0
%83 = shufflevector <4 x i64> %82, <4 x i64> poison, <4 x i32> zeroinitializer
br label %84
84: ; preds = %84, %77
%85 = phi i64 [ 0, %77 ], [ %97, %84 ]
%86 = phi <4 x i64> [ <i64 0, i64 1, i64 2, i64 3>, %77 ], [ %98, %84 ]
%87 = add <4 x i64> %86, %80
%88 = add <4 x i64> %83, %86
%89 = trunc <4 x i64> %87 to <4 x i32>
%90 = trunc <4 x i64> %88 to <4 x i32>
%91 = xor <4 x i32> %89, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%92 = xor <4 x i32> %90, <i32 305442014, i32 305442014, i32 305442014, i32 305442014>
%93 = getelementptr inbounds i32, i32* %6, i64 %85
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %91, <4 x i32>* %94
%95 = getelementptr inbounds i32, i32* %93, i64 4
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> %92, <4 x i32>* %96
%97 = add nuw i64 %85, 8
%98 = add <4 x i64> %86, <i64 8, i64 8, i64 8, i64 8>
%99 = icmp eq i64 %97, %78
br i1 %99, label %100, label %84
100: ; preds = %84
%101 = icmp eq i64 %75, %78
br i1 %101, label %119, label %102
102: ; preds = %74, %100
%103 = phi i64 [ 0, %74 ], [ %78, %100 ]
br label %127
104: ; preds = %61
%105 = trunc i64 %7 to i8
%106 = xor i8 %105, -34
store i8 %106, i8* %0
%107 = icmp eq i64 %62, 1
br i1 %107, label %71, label %108
108: ; preds = %104
%109 = trunc i64 %7 to i8
%110 = add i8 %109, 1
%111 = xor i8 %110, -34
%112 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %111, i8* %112
%113 = icmp eq i64 %62, 2
br i1 %113, label %71, label %114
114: ; preds = %108
%115 = trunc i64 %7 to i8
%116 = add i8 %115, 2
%117 = xor i8 %116, -34
%118 = getelementptr inbounds i8, i8* %0, i64 2
store i8 %117, i8* %118
br label %71
119: ; preds = %127, %100, %71
%120 = and i64 %3, 3
%121 = icmp eq i64 %120, 0
br i1 %121, label %146, label %122
122: ; preds = %119
%123 = add i64 %72, %2
%124 = trunc i64 %123 to i8
%125 = xor i8 %124, -34
store i8 %125, i8* %1
%126 = icmp eq i64 %120, 1
br i1 %126, label %146, label %135
127: ; preds = %102, %127
%128 = phi i64 [ %133, %127 ], [ %103, %102 ]
%129 = add i64 %128, %2
%130 = trunc i64 %129 to i32
%131 = xor i32 %130, 305442014
%132 = getelementptr inbounds i32, i32* %6, i64 %128
store i32 %131, i32* %132
%133 = add nuw nsw i64 %128, 1
%134 = icmp eq i64 %133, %75
br i1 %134, label %119, label %127
135: ; preds = %122
%136 = trunc i64 %123 to i8
%137 = add i8 %136, 1
%138 = xor i8 %137, -34
%139 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %138, i8* %139
%140 = icmp eq i64 %120, 2
br i1 %140, label %146, label %141
141: ; preds = %135
%142 = trunc i64 %123 to i8
%143 = add i8 %142, 2
%144 = xor i8 %143, -34
%145 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %144, i8* %145
br label %146
146: ; preds = %122, %135, %141, %119
ret void
}