#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 EINVAL;
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stderr;
int verify_data(char *tx_buf, char *rx_buf, size_t tx_buf_size,
                size_t rx_buf_size) {
  int *transmit_buffer, *receive_buffer;
  size_t i, rx_data_same, rx_data_units;
  double match_fraction;
  transmit_buffer = (int *)tx_buf;
  receive_buffer = (int *)rx_buf;
  for (i = 0; i < tx_buf_size / sizeof(int); i++) {
    if (transmit_buffer[i] != ((int)(0x1234ACDE ^ (i)))) {
      fprintf(stderr,
              "Test failed! The transmit buffer was overwritten "
              "at byte %zu.\n",
              i);
      fprintf(stderr, "Expected 0x%08x, found 0x%08x.\n",
              ((int)(0x1234ACDE ^ (i))), tx_buf[i]);
      return -EINVAL;
    }
  }
  for (i = 0; i < tx_buf_size % sizeof(int); i++) {
    if (tx_buf[i] != ((int)(0x1234ACDE ^ (i + tx_buf_size / sizeof(int))))) {
      fprintf(stderr,
              "Test failed! The transmit buffer was overwritten "
              "at byte %zu.\n",
              i);
      fprintf(stderr, "Expected 0x%08x, found 0x%08x.\n",
              ((int)(0x1234ACDE ^ (i))), tx_buf[i]);
      return -EINVAL;
    }
  }
  rx_data_same = 0;
  for (i = 0; i < rx_buf_size / sizeof(int); i++) {
    if (receive_buffer[i] == ((int)(0x1234ACDE ^ (i + tx_buf_size)))) {
      rx_data_same += 1;
    }
  }
  for (i = 0; i < rx_buf_size % sizeof(int); i++) {
    if (rx_buf[i] ==
        ((int)(0x1234ACDE ^ (i + tx_buf_size + rx_buf_size / sizeof(int))))) {
      rx_data_same += 1;
    }
  }
  rx_data_units = rx_buf_size / sizeof(int) + rx_buf_size % sizeof(int);
  if (rx_data_same == rx_data_units) {
    fprintf(stderr, "Test Failed! The receive buffer was not updated.\n");
    return -EINVAL;
  } else if (rx_data_same >= rx_data_units / 10) {
    match_fraction = ((double)rx_data_same) / ((double)rx_data_units);
    printf("Warning: %0.2f%% of the receive buffer matches the "
           "initialization pattern.\n",
           match_fraction * 100.0);
    printf("This may mean that the receive buffer was not properly "
           "updated.\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<verify_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    11f6 <verify_data+0xd6>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
xor    $0x1234acde,%rcx
cmp    %ecx,%eax
je     11e0 <verify_data+0xc0>
mov    0x2e56(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rdx
lea    0xe99(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2e3b(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rax
xor    $0x1234acde,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
lea    0xea9(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xor    %eax,%eax
mov    0x2e02(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1478 <verify_data+0x358>
jmp    11e5 <verify_data+0xc5>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1150 <verify_data+0x30>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
and    $0x3,%rcx
cmp    %rcx,%rax
jae    12b0 <verify_data+0x190>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
mov    -0x20(%rbp),%rdx
shr    $0x2,%rdx
add    %rdx,%rcx
xor    $0x1234acde,%rcx
cmp    %ecx,%eax
je     129a <verify_data+0x17a>
mov    0x2d9c(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rdx
lea    0xddf(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    0x2d81(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rax
xor    $0x1234acde,%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
lea    0xdef(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xor    %eax,%eax
mov    0x2d48(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1478 <verify_data+0x358>
jmp    129f <verify_data+0x17f>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11fe <verify_data+0xde>
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    1319 <verify_data+0x1f9>
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x40(%rbp),%rcx
add    -0x20(%rbp),%rcx
xor    $0x1234acde,%rcx
cmp    %ecx,%eax
jne    1303 <verify_data+0x1e3>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1308 <verify_data+0x1e8>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12c0 <verify_data+0x1a0>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
and    $0x3,%rcx
cmp    %rcx,%rax
jae    1386 <verify_data+0x266>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
add    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%rdx
shr    $0x2,%rdx
add    %rdx,%rcx
xor    $0x1234acde,%rcx
cmp    %ecx,%eax
jne    1370 <verify_data+0x250>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1375 <verify_data+0x255>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1321 <verify_data+0x201>
mov    -0x28(%rbp),%rax
shr    $0x2,%rax
mov    -0x28(%rbp),%rcx
and    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    13d5 <verify_data+0x2b5>
mov    0x2c2e(%rip),%rax
mov    (%rax),%edi
lea    0xcd4(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
xor    %eax,%eax
mov    0x2c0d(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    1478 <verify_data+0x358>
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x50(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x60(%rbp),%rax
cmp    %rcx,%rax
jb     146c <verify_data+0x34c>
movq   -0x48(%rbp),%xmm0
movaps 0xc09(%rip),%xmm3
punpckldq %xmm3,%xmm0
movapd 0xc0d(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movq   -0x50(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xbb5(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
lea    0xc6a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xca8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1471 <verify_data+0x351>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<verify_data>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%r15
mov    %rdx,%rax
shr    $0x2,%rax
cmp    $0x4,%rdx
jb     1177 <verify_data+0x47>
cmp    $0x2,%rax
mov    $0x1,%edi
cmovae %rax,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
xor    $0x1234acde,%ebp
cmp    %ebp,(%r15,%rbx,4)
jne    11b1 <verify_data+0x81>
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1160 <verify_data+0x30>
mov    %rdx,%rdi
and    $0x3,%rdi
je     119d <verify_data+0x6d>
movsbl (%r15),%ebp
mov    %eax,%ebx
xor    $0x1234acde,%ebx
xor    %r14d,%r14d
cmp    %ebp,%ebx
jne    11e4 <verify_data+0xb4>
cmp    $0x1,%rdi
jne    1242 <verify_data+0x112>
mov    %rcx,%r8
shr    $0x2,%r8
cmp    $0x4,%rcx
jae    1224 <verify_data+0xf4>
xor    %ebp,%ebp
jmp    137f <verify_data+0x24f>
mov    0x2e28(%rip),%r12
mov    (%r12),%edi
lea    0xea5(%rip),%rsi
xor    %r14d,%r14d
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    (%r12),%edi
movsbl (%r15,%rbx,1),%ecx
lea    0xec7(%rip),%rsi
mov    %ebp,%edx
jmp    1218 <verify_data+0xe8>
xor    %ebx,%ebx
mov    0x2df3(%rip),%rbp
mov    0x0(%rbp),%edi
lea    0xe71(%rip),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0x0(%rbp),%edi
mov    %ebx,%edx
xor    $0x1234acde,%edx
movsbl (%r15,%rbx,1),%ecx
lea    0xe8f(%rip),%rsi
xor    %eax,%eax
call   1050 <fprintf@plt>
jmp    13fa <verify_data+0x2ca>
cmp    $0x2,%r8
mov    $0x1,%r9d
cmovae %r8,%r9
cmp    $0x4,%r9
jae    1283 <verify_data+0x153>
xor    %r10d,%r10d
xor    %ebp,%ebp
jmp    1348 <verify_data+0x218>
movsbl 0x1(%r15),%r8d
lea    0x1(%rax),%ebp
xor    $0x1234acde,%ebp
mov    $0x1,%ebx
cmp    %r8d,%ebp
jne    11e6 <verify_data+0xb6>
cmp    $0x2,%rdi
je     119d <verify_data+0x6d>
movsbl 0x2(%r15),%edi
add    $0x2,%eax
xor    $0x1234acde,%eax
mov    $0x2,%ebx
cmp    %edi,%eax
je     119d <verify_data+0x6d>
jmp    11e6 <verify_data+0xb6>
mov    %r9,%r10
and    $0xfffffffffffffffc,%r10
movq   %rdx,%xmm0
pshufd $0x44,%xmm0,%xmm9
lea    0x2(%rdx),%rdi
movq   %rdi,%xmm1
pshufd $0x44,%xmm1,%xmm10
pxor   %xmm1,%xmm1
movdqa 0xd50(%rip),%xmm2
xor    %ebp,%ebp
movdqa 0xd55(%rip),%xmm11
movdqa 0xd5d(%rip),%xmm6
movdqa 0xd64(%rip),%xmm8
pxor   %xmm5,%xmm5
movq   (%rsi,%rbp,4),%xmm7
movq   0x8(%rsi,%rbp,4),%xmm0
movdqa %xmm2,%xmm3
paddq  %xmm9,%xmm3
movdqa %xmm10,%xmm4
paddq  %xmm2,%xmm4
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xe8,%xmm4,%xmm4
pxor   %xmm11,%xmm3
pcmpeqd %xmm7,%xmm3
pxor   %xmm11,%xmm4
pcmpeqd %xmm0,%xmm4
pshufd $0xd4,%xmm3,%xmm0
pand   %xmm6,%xmm0
paddq  %xmm0,%xmm1
pshufd $0xd4,%xmm4,%xmm0
pand   %xmm6,%xmm0
paddq  %xmm0,%xmm5
add    $0x4,%rbp
paddq  %xmm8,%xmm2
cmp    %rbp,%r10
jne    12d0 <verify_data+0x1a0>
paddq  %xmm1,%xmm5
pshufd $0xee,%xmm5,%xmm0
paddq  %xmm5,%xmm0
movq   %xmm0,%rbp
cmp    %r10,%r9
je     137f <verify_data+0x24f>
sub    %r10,%r9
lea    (%rsi,%r10,4),%r11
add    %rdx,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r10,%rbx,1),%eax
xor    $0x1234acde,%eax
xor    %edi,%edi
cmp    %eax,(%r11,%rbx,4)
sete   %dil
add    %rdi,%rbp
add    $0x1,%rbx
cmp    %rbx,%r9
jne    1360 <verify_data+0x230>
and    $0x3,%rcx
je     13d8 <verify_data+0x2a8>
add    %r8,%rdx
movsbl (%rsi),%eax
mov    %edx,%edi
xor    $0x1234acde,%edi
xor    %ebx,%ebx
cmp    %eax,%edi
sete   %bl
add    %rbx,%rbp
cmp    $0x1,%rcx
je     13d8 <verify_data+0x2a8>
movsbl 0x1(%rsi),%eax
lea    0x1(%rdx),%edi
xor    $0x1234acde,%edi
xor    %ebx,%ebx
cmp    %eax,%edi
sete   %bl
add    %rbx,%rbp
cmp    $0x2,%rcx
je     13d8 <verify_data+0x2a8>
movsbl 0x2(%rsi),%eax
add    $0x2,%edx
xor    $0x1234acde,%edx
xor    %esi,%esi
cmp    %eax,%edx
sete   %sil
add    %rsi,%rbp
add    %rcx,%r8
cmp    %r8,%rbp
jne    1410 <verify_data+0x2e0>
mov    0x2bf9(%rip),%rax
mov    (%rax),%edi
lea    0xcd7(%rip),%rsi
xor    %r14d,%r14d
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0x2bd7(%rip),%rax
sub    (%rax),%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0xcccccccccccccccd,%rcx
cc cc cc
mov    %r8,%rax
mul    %rcx
shr    $0x3,%rdx
xor    %r14d,%r14d
cmp    %rdx,%rbp
jb     1404 <verify_data+0x2d4>
movq   %rbp,%xmm1
movdqa 0xc07(%rip),%xmm2
punpckldq %xmm2,%xmm1
movapd 0xc0b(%rip),%xmm3
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movq   %r8,%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm3,%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
mulsd  0xbe6(%rip),%xmm0
lea    0xc78(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
lea    0xcb6(%rip),%rdi
call   1030 <puts@plt>
jmp    1404 <verify_data+0x2d4>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [63 x i8] c"Test failed! The transmit buffer was overwritten at byte %zu.\0A\00"
@.str.1 = [32 x i8] c"Expected 0x%08x, found 0x%08x.\0A\00"
@EINVAL = global i32 0
@.str.2 = [50 x i8] c"Test Failed! The receive buffer was not updated.\0A\00"
@.str.3 = [76 x i8] c"Warning: %0.2f%% of the receive buffer matches the initialization pattern.\0A\00"
@.str.4 = [65 x i8] c"This may mean that the receive buffer was not properly updated.\0A\00"
define i32 @verify_data(i8* %0, i8* %1, i64 %2, i64 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca double
store i8* %0, i8** %6
store i8* %1, i8** %7
store i64 %2, i64* %8
store i64 %3, i64* %9
%16 = load i8*, i8** %6
%17 = bitcast i8* %16 to i32*
store i32* %17, i32** %10
%18 = load i8*, i8** %7
%19 = bitcast i8* %18 to i32*
store i32* %19, i32** %11
store i64 0, i64* %12
br label %20
20: ; preds = %51, %4
%21 = load i64, i64* %12
%22 = load i64, i64* %8
%23 = udiv i64 %22, 4
%24 = icmp ult i64 %21, %23
br i1 %24, label %25, label %54
25: ; preds = %20
%26 = load i32*, i32** %10
%27 = load i64, i64* %12
%28 = getelementptr inbounds i32, i32* %26, i64 %27
%29 = load i32, i32* %28
%30 = load i64, i64* %12
%31 = xor i64 305442014, %30
%32 = trunc i64 %31 to i32
%33 = icmp ne i32 %29, %32
br i1 %33, label %34, label %50
34: ; preds = %25
%35 = load i32, i32* @stderr
%36 = load i64, i64* %12
%37 = call i32 (i32, i8*, ...) @fprintf(i32 %35, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0), i64 %36)
%38 = load i32, i32* @stderr
%39 = load i64, i64* %12
%40 = xor i64 305442014, %39
%41 = trunc i64 %40 to i32
%42 = load i8*, i8** %6
%43 = load i64, i64* %12
%44 = getelementptr inbounds i8, i8* %42, i64 %43
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
%47 = call i32 (i32, i8*, ...) @fprintf(i32 %38, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i32 %41, i32 %46)
%48 = load i32, i32* @EINVAL
%49 = sub nsw i32 0, %48
store i32 %49, i32* %5
br label %176
50: ; preds = %25
br label %51
51: ; preds = %50
%52 = load i64, i64* %12
%53 = add i64 %52, 1
store i64 %53, i64* %12
br label %20
54: ; preds = %20
store i64 0, i64* %12
br label %55
55: ; preds = %90, %54
%56 = load i64, i64* %12
%57 = load i64, i64* %8
%58 = urem i64 %57, 4
%59 = icmp ult i64 %56, %58
br i1 %59, label %60, label %93
60: ; preds = %55
%61 = load i8*, i8** %6
%62 = load i64, i64* %12
%63 = getelementptr inbounds i8, i8* %61, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = load i64, i64* %12
%67 = load i64, i64* %8
%68 = udiv i64 %67, 4
%69 = add i64 %66, %68
%70 = xor i64 305442014, %69
%71 = trunc i64 %70 to i32
%72 = icmp ne i32 %65, %71
br i1 %72, label %73, label %89
73: ; preds = %60
%74 = load i32, i32* @stderr
%75 = load i64, i64* %12
%76 = call i32 (i32, i8*, ...) @fprintf(i32 %74, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0), i64 %75)
%77 = load i32, i32* @stderr
%78 = load i64, i64* %12
%79 = xor i64 305442014, %78
%80 = trunc i64 %79 to i32
%81 = load i8*, i8** %6
%82 = load i64, i64* %12
%83 = getelementptr inbounds i8, i8* %81, i64 %82
%84 = load i8, i8* %83
%85 = sext i8 %84 to i32
%86 = call i32 (i32, i8*, ...) @fprintf(i32 %77, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i32 %80, i32 %85)
%87 = load i32, i32* @EINVAL
%88 = sub nsw i32 0, %87
store i32 %88, i32* %5
br label %176
89: ; preds = %60
br label %90
90: ; preds = %89
%91 = load i64, i64* %12
%92 = add i64 %91, 1
store i64 %92, i64* %12
br label %55
93: ; preds = %55
store i64 0, i64* %13
store i64 0, i64* %12
br label %94
94: ; preds = %114, %93
%95 = load i64, i64* %12
%96 = load i64, i64* %9
%97 = udiv i64 %96, 4
%98 = icmp ult i64 %95, %97
br i1 %98, label %99, label %117
99: ; preds = %94
%100 = load i32*, i32** %11
%101 = load i64, i64* %12
%102 = getelementptr inbounds i32, i32* %100, i64 %101
%103 = load i32, i32* %102
%104 = load i64, i64* %12
%105 = load i64, i64* %8
%106 = add i64 %104, %105
%107 = xor i64 305442014, %106
%108 = trunc i64 %107 to i32
%109 = icmp eq i32 %103, %108
br i1 %109, label %110, label %113
110: ; preds = %99
%111 = load i64, i64* %13
%112 = add i64 %111, 1
store i64 %112, i64* %13
br label %113
113: ; preds = %110, %99
br label %114
114: ; preds = %113
%115 = load i64, i64* %12
%116 = add i64 %115, 1
store i64 %116, i64* %12
br label %94
117: ; preds = %94
store i64 0, i64* %12
br label %118
118: ; preds = %142, %117
%119 = load i64, i64* %12
%120 = load i64, i64* %9
%121 = urem i64 %120, 4
%122 = icmp ult i64 %119, %121
br i1 %122, label %123, label %145
123: ; preds = %118
%124 = load i8*, i8** %7
%125 = load i64, i64* %12
%126 = getelementptr inbounds i8, i8* %124, i64 %125
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = load i64, i64* %12
%130 = load i64, i64* %8
%131 = add i64 %129, %130
%132 = load i64, i64* %9
%133 = udiv i64 %132, 4
%134 = add i64 %131, %133
%135 = xor i64 305442014, %134
%136 = trunc i64 %135 to i32
%137 = icmp eq i32 %128, %136
br i1 %137, label %138, label %141
138: ; preds = %123
%139 = load i64, i64* %13
%140 = add i64 %139, 1
store i64 %140, i64* %13
br label %141
141: ; preds = %138, %123
br label %142
142: ; preds = %141
%143 = load i64, i64* %12
%144 = add i64 %143, 1
store i64 %144, i64* %12
br label %118
145: ; preds = %118
%146 = load i64, i64* %9
%147 = udiv i64 %146, 4
%148 = load i64, i64* %9
%149 = urem i64 %148, 4
%150 = add i64 %147, %149
store i64 %150, i64* %14
%151 = load i64, i64* %13
%152 = load i64, i64* %14
%153 = icmp eq i64 %151, %152
br i1 %153, label %154, label %159
154: ; preds = %145
%155 = load i32, i32* @stderr
%156 = call i32 (i32, i8*, ...) @fprintf(i32 %155, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0))
%157 = load i32, i32* @EINVAL
%158 = sub nsw i32 0, %157
store i32 %158, i32* %5
br label %176
159: ; preds = %145
%160 = load i64, i64* %13
%161 = load i64, i64* %14
%162 = udiv i64 %161, 10
%163 = icmp uge i64 %160, %162
br i1 %163, label %164, label %174
164: ; preds = %159
%165 = load i64, i64* %13
%166 = uitofp i64 %165 to double
%167 = load i64, i64* %14
%168 = uitofp i64 %167 to double
%169 = fdiv double %166, %168
store double %169, double* %15
%170 = load double, double* %15
%171 = fmul double %170, 1.000000e+02
%172 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.3, i64 0, i64 0), double %171)
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.4, i64 0, i64 0))
br label %174
174: ; preds = %164, %159
br label %175
175: ; preds = %174
store i32 0, i32* %5
br label %176
176: ; preds = %175, %154, %73, %34
%177 = load i32, i32* %5
ret i32 %177
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [63 x i8] c"Test failed! The transmit buffer was overwritten at byte %zu.\0A\00"
@.str.1 = [32 x i8] c"Expected 0x%08x, found 0x%08x.\0A\00"
@EINVAL = global i32 0
@.str.2 = [50 x i8] c"Test Failed! The receive buffer was not updated.\0A\00"
@.str.3 = [76 x i8] c"Warning: %0.2f%% of the receive buffer matches the initialization pattern.\0A\00"
@str = [64 x i8] c"This may mean that the receive buffer was not properly updated.\00"
define i32 @verify_data(i8* nocapture %0, i8* nocapture %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 %11, label %9
9: ; preds = %4
%10 = call i64 @llvm.umax.i64(i64 %7, i64 1)
br label %14
11: ; preds = %31, %4
%12 = and i64 %2, 3
%13 = icmp eq i64 %12, 0
br i1 %13, label %34, label %80
14: ; preds = %9, %31
%15 = phi i64 [ %32, %31 ], [ 0, %9 ]
%16 = getelementptr inbounds i32, i32* %5, i64 %15
%17 = load i32, i32* %16
%18 = trunc i64 %15 to i32
%19 = xor i32 %18, 305442014
%20 = icmp eq i32 %17, %19
br i1 %20, label %31, label %21
21: ; preds = %14
%22 = load i32, i32* @stderr
%23 = tail call i32 (i32, i8*, ...) @fprintf(i32 %22, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0), i64 %15)
%24 = load i32, i32* @stderr
%25 = getelementptr inbounds i8, i8* %0, i64 %15
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = tail call i32 (i32, i8*, ...) @fprintf(i32 %24, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i32 %19, i32 %27)
%29 = load i32, i32* @EINVAL
%30 = sub nsw i32 0, %29
br label %186
31: ; preds = %14
%32 = add nuw nsw i64 %15, 1
%33 = icmp eq i64 %32, %10
br i1 %33, label %11, label %14
34: ; preds = %111, %99, %109, %11
%35 = lshr i64 %3, 2
%36 = icmp ult i64 %3, 4
br i1 %36, label %119, label %37
37: ; preds = %34
%38 = call i64 @llvm.umax.i64(i64 %35, i64 1)
%39 = icmp ult i64 %38, 4
br i1 %39, label %77, label %40
40: ; preds = %37
%41 = and i64 %38, 4611686018427387900
%42 = insertelement <2 x i64> poison, i64 %2, i64 0
%43 = shufflevector <2 x i64> %42, <2 x i64> poison, <2 x i32> zeroinitializer
%44 = add i64 %2, 2
%45 = insertelement <2 x i64> poison, i64 %44, i64 0
%46 = shufflevector <2 x i64> %45, <2 x i64> poison, <2 x i32> zeroinitializer
br label %47
47: ; preds = %47, %40
%48 = phi i64 [ 0, %40 ], [ %70, %47 ]
%49 = phi <2 x i64> [ <i64 0, i64 1>, %40 ], [ %71, %47 ]
%50 = phi <2 x i64> [ zeroinitializer, %40 ], [ %68, %47 ]
%51 = phi <2 x i64> [ zeroinitializer, %40 ], [ %69, %47 ]
%52 = getelementptr inbounds i32, i32* %6, i64 %48
%53 = bitcast i32* %52 to <2 x i32>*
%54 = load <2 x i32>, <2 x i32>* %53
%55 = getelementptr inbounds i32, i32* %52, i64 2
%56 = bitcast i32* %55 to <2 x i32>*
%57 = load <2 x i32>, <2 x i32>* %56
%58 = add <2 x i64> %49, %43
%59 = add <2 x i64> %46, %49
%60 = trunc <2 x i64> %58 to <2 x i32>
%61 = trunc <2 x i64> %59 to <2 x i32>
%62 = xor <2 x i32> %60, <i32 305442014, i32 305442014>
%63 = xor <2 x i32> %61, <i32 305442014, i32 305442014>
%64 = icmp eq <2 x i32> %54, %62
%65 = icmp eq <2 x i32> %57, %63
%66 = zext <2 x i1> %64 to <2 x i64>
%67 = zext <2 x i1> %65 to <2 x i64>
%68 = add <2 x i64> %50, %66
%69 = add <2 x i64> %51, %67
%70 = add nuw i64 %48, 4
%71 = add <2 x i64> %49, <i64 4, i64 4>
%72 = icmp eq i64 %70, %41
br i1 %72, label %73, label %47
73: ; preds = %47
%74 = add <2 x i64> %69, %68
%75 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %74)
%76 = icmp eq i64 %38, %41
br i1 %76, label %119, label %77
77: ; preds = %37, %73
%78 = phi i64 [ 0, %37 ], [ %41, %73 ]
%79 = phi i64 [ 0, %37 ], [ %75, %73 ]
br label %133
80: ; preds = %11
%81 = load i8, i8* %0
%82 = sext i8 %81 to i32
%83 = trunc i64 %7 to i32
%84 = xor i32 %83, 305442014
%85 = icmp eq i32 %84, %82
br i1 %85, label %99, label %86
86: ; preds = %111, %101, %80
%87 = phi i64 [ 0, %80 ], [ 1, %101 ], [ 2, %111 ]
%88 = getelementptr inbounds i8, i8* %0, i64 %87
%89 = load i32, i32* @stderr
%90 = tail call i32 (i32, i8*, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str, i64 0, i64 0), i64 %87)
%91 = load i32, i32* @stderr
%92 = trunc i64 %87 to i32
%93 = xor i32 %92, 305442014
%94 = load i8, i8* %88
%95 = sext i8 %94 to i32
%96 = tail call i32 (i32, i8*, ...) @fprintf(i32 %91, i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i32 %93, i32 %95)
%97 = load i32, i32* @EINVAL
%98 = sub nsw i32 0, %97
br label %186
99: ; preds = %80
%100 = icmp eq i64 %12, 1
br i1 %100, label %34, label %101
101: ; preds = %99
%102 = getelementptr inbounds i8, i8* %0, i64 1
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = trunc i64 %7 to i32
%106 = add i32 %105, 1
%107 = xor i32 %106, 305442014
%108 = icmp eq i32 %107, %104
br i1 %108, label %109, label %86
109: ; preds = %101
%110 = icmp eq i64 %12, 2
br i1 %110, label %34, label %111
111: ; preds = %109
%112 = getelementptr inbounds i8, i8* %0, i64 2
%113 = load i8, i8* %112
%114 = sext i8 %113 to i32
%115 = trunc i64 %7 to i32
%116 = add i32 %115, 2
%117 = xor i32 %116, 305442014
%118 = icmp eq i32 %117, %114
br i1 %118, label %34, label %86
119: ; preds = %133, %73, %34
%120 = phi i64 [ 0, %34 ], [ %75, %73 ], [ %143, %133 ]
%121 = and i64 %3, 3
%122 = icmp eq i64 %121, 0
br i1 %122, label %167, label %123
123: ; preds = %119
%124 = add i64 %35, %2
%125 = load i8, i8* %1
%126 = sext i8 %125 to i32
%127 = trunc i64 %124 to i32
%128 = xor i32 %127, 305442014
%129 = icmp eq i32 %128, %126
%130 = zext i1 %129 to i64
%131 = add i64 %120, %130
%132 = icmp eq i64 %121, 1
br i1 %132, label %167, label %146
133: ; preds = %77, %133
%134 = phi i64 [ %144, %133 ], [ %78, %77 ]
%135 = phi i64 [ %143, %133 ], [ %79, %77 ]
%136 = getelementptr inbounds i32, i32* %6, i64 %134
%137 = load i32, i32* %136
%138 = add i64 %134, %2
%139 = trunc i64 %138 to i32
%140 = xor i32 %139, 305442014
%141 = icmp eq i32 %137, %140
%142 = zext i1 %141 to i64
%143 = add i64 %135, %142
%144 = add nuw nsw i64 %134, 1
%145 = icmp eq i64 %144, %38
br i1 %145, label %119, label %133
146: ; preds = %123
%147 = getelementptr inbounds i8, i8* %1, i64 1
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = trunc i64 %124 to i32
%151 = add i32 %150, 1
%152 = xor i32 %151, 305442014
%153 = icmp eq i32 %152, %149
%154 = zext i1 %153 to i64
%155 = add i64 %131, %154
%156 = icmp eq i64 %121, 2
br i1 %156, label %167, label %157
157: ; preds = %146
%158 = getelementptr inbounds i8, i8* %1, i64 2
%159 = load i8, i8* %158
%160 = sext i8 %159 to i32
%161 = trunc i64 %124 to i32
%162 = add i32 %161, 2
%163 = xor i32 %162, 305442014
%164 = icmp eq i32 %163, %160
%165 = zext i1 %164 to i64
%166 = add i64 %155, %165
br label %167
167: ; preds = %123, %146, %157, %119
%168 = phi i64 [ %120, %119 ], [ %131, %123 ], [ %155, %146 ], [ %166, %157 ]
%169 = add nuw nsw i64 %35, %121
%170 = icmp eq i64 %168, %169
br i1 %170, label %171, label %176
171: ; preds = %167
%172 = load i32, i32* @stderr
%173 = tail call i32 (i32, i8*, ...) @fprintf(i32 %172, i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.2, i64 0, i64 0))
%174 = load i32, i32* @EINVAL
%175 = sub nsw i32 0, %174
br label %186
176: ; preds = %167
%177 = udiv i64 %169, 10
%178 = icmp ult i64 %168, %177
br i1 %178, label %186, label %179
179: ; preds = %176
%180 = uitofp i64 %168 to double
%181 = uitofp i64 %169 to double
%182 = fdiv double %180, %181
%183 = fmul double %182, 1.000000e+02
%184 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @.str.3, i64 0, i64 0), double %183)
%185 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @str, i64 0, i64 0))
br label %186
186: ; preds = %179, %176, %171, %86, %21
%187 = phi i32 [ %30, %21 ], [ %98, %86 ], [ %175, %171 ], [ 0, %176 ], [ 0, %179 ]
ret i32 %187
}