#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*/ assert(int);
void swap(const void *addr1, const void *addr2, size_t size) {
  assert((((addr1))) && "Unexpected null pointer.");
  ;
  assert((((addr2))) && "Unexpected null pointer.");
  ;
  char *ptr1 = (char *)addr1;
  char *ptr2 = (char *)addr2;
  for (int b = 0; b < size; ++b) {
    const char c = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = c;
    ++ptr1;
    ++ptr2;
  }
}


x86 assembly (clang, -O0):
<swap>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x2e(%rbp)
je     113e <swap+0x2e>
mov    $0x1,%al
mov    %al,-0x2e(%rbp)
jmp    113e <swap+0x2e>
mov    -0x2e(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x2f(%rbp)
je     1165 <swap+0x55>
mov    $0x1,%al
mov    %al,-0x2f(%rbp)
jmp    1165 <swap+0x55>
mov    -0x2f(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11db <swap+0xcb>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x2d(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x2d(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1189 <swap+0x79>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<swap>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
xor    %edi,%edi
test   %r12,%r12
setne  %dil
call   1030 <assert@plt>
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1030 <assert@plt>
test   %r14,%r14
je     1211 <swap+0x101>
cmp    $0x8,%r14
jb     1166 <swap+0x56>
lea    (%r15,%r14,1),%rax
cmp    %r12,%rax
jbe    121d <swap+0x10d>
lea    (%r12,%r14,1),%rax
cmp    %r15,%rax
jbe    121d <swap+0x10d>
xor    %r8d,%r8d
mov    %r12,%rcx
mov    %r15,%rdx
mov    %r8,%rsi
not    %rsi
add    %r14,%rsi
mov    %r14,%rdi
and    $0x3,%rdi
je     11ac <swap+0x9c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rcx),%ebx
movzbl (%rdx),%eax
mov    %al,(%rcx)
mov    %bl,(%rdx)
add    $0x1,%rcx
add    $0x1,%rdx
add    $0x1,%r8
add    $0xffffffffffffffff,%rdi
jne    1190 <swap+0x80>
cmp    $0x3,%rsi
jb     1211 <swap+0x101>
sub    %r8,%r14
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movzbl (%rcx,%rax,1),%esi
movzbl (%rdx,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
mov    %sil,(%rdx,%rax,1)
movzbl 0x1(%rcx,%rax,1),%esi
movzbl 0x1(%rdx,%rax,1),%ebx
mov    %bl,0x1(%rcx,%rax,1)
mov    %sil,0x1(%rdx,%rax,1)
movzbl 0x2(%rcx,%rax,1),%esi
movzbl 0x2(%rdx,%rax,1),%ebx
mov    %bl,0x2(%rcx,%rax,1)
mov    %sil,0x2(%rdx,%rax,1)
movzbl 0x3(%rcx,%rax,1),%esi
movzbl 0x3(%rdx,%rax,1),%ebx
mov    %bl,0x3(%rcx,%rax,1)
mov    %sil,0x3(%rdx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r14
jne    11c0 <swap+0xb0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
cmp    $0x20,%r14
jae    122b <swap+0x11b>
xor    %r8d,%r8d
jmp    1306 <swap+0x1f6>
mov    %r14,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1347 <swap+0x237>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
movups (%r15,%rcx,1),%xmm2
movups 0x10(%r15,%rcx,1),%xmm3
movups %xmm2,(%r12,%rcx,1)
movups %xmm3,0x10(%r12,%rcx,1)
movups %xmm0,(%r15,%rcx,1)
movups %xmm1,0x10(%r15,%rcx,1)
movups 0x20(%r12,%rcx,1),%xmm0
movups 0x30(%r12,%rcx,1),%xmm1
movups 0x20(%r15,%rcx,1),%xmm2
movups 0x30(%r15,%rcx,1),%xmm3
movups %xmm2,0x20(%r12,%rcx,1)
movups %xmm3,0x30(%r12,%rcx,1)
movups %xmm0,0x20(%r15,%rcx,1)
movups %xmm1,0x30(%r15,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1260 <swap+0x150>
test   $0x1,%dl
je     12f7 <swap+0x1e7>
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
movups (%r15,%rcx,1),%xmm2
movups 0x10(%r15,%rcx,1),%xmm3
movups %xmm2,(%r12,%rcx,1)
movups %xmm3,0x10(%r12,%rcx,1)
movups %xmm0,(%r15,%rcx,1)
movups %xmm1,0x10(%r15,%rcx,1)
cmp    %r14,%r8
je     1211 <swap+0x101>
test   $0x18,%r14b
je     1354 <swap+0x244>
mov    %r8,%rsi
mov    %r14,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r12,%r8,1),%rcx
lea    (%r15,%r8,1),%rdx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rsi,1),%rdi
mov    (%r15,%rsi,1),%rbx
mov    %rbx,(%r12,%rsi,1)
mov    %rdi,(%r15,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r8
jne    1320 <swap+0x210>
cmp    %r14,%r8
jne    116f <swap+0x5f>
jmp    1211 <swap+0x101>
xor    %ecx,%ecx
test   $0x1,%dl
jne    12cb <swap+0x1bb>
jmp    12f7 <swap+0x1e7>
add    %r8,%r15
add    %r8,%r12
jmp    1169 <swap+0x59>

LLVM IR (-O0):
@.str = [25 x i8] c"Unexpected null pointer.\00"
define void @swap(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%11 = load i8*, i8** %4
%12 = icmp ne i8* %11, null
br i1 %12, label %13, label %14
13: ; preds = %3
br label %14
14: ; preds = %13, %3
%15 = phi i1 [ false, %3 ], [ true, %13 ]
%16 = zext i1 %15 to i32
%17 = call i32 @assert(i32 %16)
%18 = load i8*, i8** %5
%19 = icmp ne i8* %18, null
br i1 %19, label %20, label %21
20: ; preds = %14
br label %21
21: ; preds = %20, %14
%22 = phi i1 [ false, %14 ], [ true, %20 ]
%23 = zext i1 %22 to i32
%24 = call i32 @assert(i32 %23)
%25 = load i8*, i8** %4
store i8* %25, i8** %7
%26 = load i8*, i8** %5
store i8* %26, i8** %8
store i32 0, i32* %9
br label %27
27: ; preds = %44, %21
%28 = load i32, i32* %9
%29 = sext i32 %28 to i64
%30 = load i64, i64* %6
%31 = icmp ult i64 %29, %30
br i1 %31, label %32, label %47
32: ; preds = %27
%33 = load i8*, i8** %7
%34 = load i8, i8* %33
store i8 %34, i8* %10
%35 = load i8*, i8** %8
%36 = load i8, i8* %35
%37 = load i8*, i8** %7
store i8 %36, i8* %37
%38 = load i8, i8* %10
%39 = load i8*, i8** %8
store i8 %38, i8* %39
%40 = load i8*, i8** %7
%41 = getelementptr inbounds i8, i8* %40, i32 1
store i8* %41, i8** %7
%42 = load i8*, i8** %8
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %8
br label %44
44: ; preds = %32
%45 = load i32, i32* %9
%46 = add nsw i32 %45, 1
store i32 %46, i32* %9
br label %27
47: ; preds = %27
ret void
}

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