#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 */
typedef int /*<<< orphan*/ uint8_t;
typedef int /*<<< orphan*/ uint64_t;

/* Variables and functions */
__attribute__((always_)) void bigint_init_raw(uint64_t *value0,
                                              unsigned int size,
                                              const void *data, size_t len) {
  size_t pad_len = (sizeof(bigint_t(size)) - len);
  uint8_t *value_byte = ((void *)value0);
  const uint8_t *data_byte = (data + len);
  while (len--)
    *(value_byte++) = *(--data_byte);
  while (pad_len--)
    *(value_byte++) = 0;
}


x86 assembly (clang, -O0):
<bigint_init_raw>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    $0x4,%eax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     1175 <bigint_init_raw+0x75>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
mov    -0x4(%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
jmp    1134 <bigint_init_raw+0x34>
jmp    117a <bigint_init_raw+0x7a>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
cmp    $0x0,%rax
je     11ad <bigint_init_raw+0xad>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x30(%rbp)
movl   $0x0,(%rax)
jmp    117a <bigint_init_raw+0x7a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<bigint_init_raw>:
push   %rax
test   %rcx,%rcx
je     12a5 <bigint_init_raw+0x195>
lea    (%rdx,%rcx,1),%rax
cmp    $0x8,%rcx
jb     1144 <bigint_init_raw+0x34>
cmp    %rdi,%rax
jbe    11d9 <bigint_init_raw+0xc9>
lea    (%rdi,%rcx,4),%r8
lea    (%rcx,%rcx,2),%r9
mov    %rdx,%rsi
sub    %r9,%rsi
cmp    %r8,%rsi
jae    11d9 <bigint_init_raw+0xc9>
mov    %rcx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%r10
and    $0x7,%r10
je     1179 <bigint_init_raw+0x69>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%rax),%edx
add    $0xfffffffffffffffc,%rax
mov    %edx,(%rdi)
add    $0x4,%rdi
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1160 <bigint_init_raw+0x50>
sub    %rsi,%r9
cmp    $0x7,%r8
jb     129f <bigint_init_raw+0x18f>
neg    %r9
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rax,%rsi,4),%edx
mov    %edx,(%rdi)
mov    -0x8(%rax,%rsi,4),%edx
mov    %edx,0x4(%rdi)
mov    -0xc(%rax,%rsi,4),%edx
mov    %edx,0x8(%rdi)
mov    -0x10(%rax,%rsi,4),%edx
mov    %edx,0xc(%rdi)
mov    -0x14(%rax,%rsi,4),%edx
mov    %edx,0x10(%rdi)
mov    -0x18(%rax,%rsi,4),%edx
mov    %edx,0x14(%rdi)
mov    -0x1c(%rax,%rsi,4),%edx
mov    %edx,0x18(%rdi)
mov    -0x20(%rax,%rsi,4),%edx
mov    %edx,0x1c(%rdi)
add    $0x20,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%r9
jne    1190 <bigint_init_raw+0x80>
jmp    129f <bigint_init_raw+0x18f>
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     12cd <bigint_init_raw+0x1bd>
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
lea    0x30(%rdi),%rsi
lea    (%rcx,%rdx,1),%r11
add    $0xfffffffffffffff0,%r11
xor    %edx,%edx
nopl   (%rax)
movdqu -0x10(%r11,%rdx,4),%xmm0
movdqu (%r11,%rdx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%rsi)
movdqu %xmm0,-0x20(%rsi)
movdqu -0x30(%r11,%rdx,4),%xmm0
movdqu -0x20(%r11,%rdx,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%rsi)
movdqu %xmm0,(%rsi)
add    $0x40,%rsi
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%r10
jne    1210 <bigint_init_raw+0x100>
neg    %rdx
test   $0x1,%r9b
je     1296 <bigint_init_raw+0x186>
lea    0x0(,%rdx,4),%r9
mov    %rax,%rsi
sub    %r9,%rsi
movdqu -0x20(%rsi),%xmm0
movdqu -0x10(%rsi),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rdi,%rdx,4)
movdqu %xmm0,0x10(%rdi,%rdx,4)
lea    (%rdi,%r8,4),%rdi
cmp    %rcx,%r8
jne    12ba <bigint_init_raw+0x1aa>
cmp    $0x4,%rcx
je     12b8 <bigint_init_raw+0x1a8>
shl    $0x2,%rcx
mov    $0x10,%edx
sub    %rcx,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
pop    %rax
ret
shl    $0x2,%r8
mov    %ecx,%r9d
and    $0x7,%r9d
sub    %r8,%rax
jmp    1147 <bigint_init_raw+0x37>
xor    %edx,%edx
test   $0x1,%r9b
jne    1269 <bigint_init_raw+0x159>
jmp    1296 <bigint_init_raw+0x186>

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

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