unsigned char *CgebScanMem(unsigned char *p, unsigned char *pend, char *magic) {
  unsigned int magic0 = ((unsigned int *)magic)[0];
  unsigned int magic1 = ((unsigned int *)magic)[1];
  for (; p < pend; p += 16)
    if (*(unsigned int *)p == magic0 && ((unsigned int *)p)[1] == magic1)
      return p;
  return ((void *)0);
}


x86 assembly (clang, -O0):
<CgebScanMem>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1173 <CgebScanMem+0x73>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
cmp    -0x24(%rbp),%eax
jne    115d <CgebScanMem+0x5d>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
cmp    -0x28(%rbp),%eax
jne    115d <CgebScanMem+0x5d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    117b <CgebScanMem+0x7b>
jmp    1162 <CgebScanMem+0x62>
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
jmp    1123 <CgebScanMem+0x23>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<CgebScanMem>:
cmp    %rsi,%rdi
jae    1123 <CgebScanMem+0x23>
mov    %rdi,%rax
mov    (%rdx),%ecx
mov    0x4(%rdx),%edx
jmp    1119 <CgebScanMem+0x19>
nop
add    $0x10,%rax
cmp    %rsi,%rax
jae    1123 <CgebScanMem+0x23>
cmp    %ecx,(%rax)
jne    1110 <CgebScanMem+0x10>
cmp    %edx,0x4(%rax)
jne    1110 <CgebScanMem+0x10>
ret
xor    %eax,%eax
ret

LLVM IR (-O0):
define i8* @CgebScanMem(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
%10 = load i8*, i8** %7
%11 = bitcast i8* %10 to i32*
%12 = getelementptr inbounds i32, i32* %11, i64 0
%13 = load i32, i32* %12
store i32 %13, i32* %8
%14 = load i8*, i8** %7
%15 = bitcast i8* %14 to i32*
%16 = getelementptr inbounds i32, i32* %15, i64 1
%17 = load i32, i32* %16
store i32 %17, i32* %9
br label %18
18: ; preds = %38, %3
%19 = load i8*, i8** %5
%20 = load i8*, i8** %6
%21 = icmp ult i8* %19, %20
br i1 %21, label %22, label %41
22: ; preds = %18
%23 = load i8*, i8** %5
%24 = bitcast i8* %23 to i32*
%25 = load i32, i32* %24
%26 = load i32, i32* %8
%27 = icmp eq i32 %25, %26
br i1 %27, label %28, label %37
28: ; preds = %22
%29 = load i8*, i8** %5
%30 = bitcast i8* %29 to i32*
%31 = getelementptr inbounds i32, i32* %30, i64 1
%32 = load i32, i32* %31
%33 = load i32, i32* %9
%34 = icmp eq i32 %32, %33
br i1 %34, label %35, label %37
35: ; preds = %28
%36 = load i8*, i8** %5
store i8* %36, i8** %4
br label %42
37: ; preds = %28, %22
br label %38
38: ; preds = %37
%39 = load i8*, i8** %5
%40 = getelementptr inbounds i8, i8* %39, i64 16
store i8* %40, i8** %5
br label %18
41: ; preds = %18
store i8* null, i8** %4
br label %42
42: ; preds = %41, %35
%43 = load i8*, i8** %4
ret i8* %43
}

LLVM IR (-O2):
define i8* @CgebScanMem(i8* %0, i8* readnone %1, i8* nocapture %2) {
%4 = bitcast i8* %2 to i32*
%5 = load i32, i32* %4
%6 = getelementptr inbounds i8, i8* %2, i64 4
%7 = bitcast i8* %6 to i32*
%8 = load i32, i32* %7
%9 = icmp ult i8* %0, %1
br i1 %9, label %10, label %23
10: ; preds = %3, %20
%11 = phi i8* [ %21, %20 ], [ %0, %3 ]
%12 = bitcast i8* %11 to i32*
%13 = load i32, i32* %12
%14 = icmp eq i32 %13, %5
br i1 %14, label %15, label %20
15: ; preds = %10
%16 = getelementptr inbounds i8, i8* %11, i64 4
%17 = bitcast i8* %16 to i32*
%18 = load i32, i32* %17
%19 = icmp eq i32 %18, %8
br i1 %19, label %23, label %20
20: ; preds = %10, %15
%21 = getelementptr inbounds i8, i8* %11, i64 16
%22 = icmp ult i8* %21, %1
br i1 %22, label %10, label %23
23: ; preds = %15, %20, %3
%24 = phi i8* [ null, %3 ], [ null, %20 ], [ %11, %15 ]
ret i8* %24
}