#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*/ __m128i;

/* Variables and functions */
int /*<<< orphan*/ storeu(void const *, int /*<<< orphan*/);
void store_partial_from_left_to_right(const void *p, __m128i x, unsigned n) {
  if (n == 0) {
    return;
  } else if (n >= 16) {
    storeu(p, x);
  } else {
    unsigned i;
    char *p_ = (char *)p;
    char *x_ = (char *)&x;
    for (i = 0; i < n; ++i) {
      p_[(16 - n) + i] = x_[i];
    }
  }
}


x86 assembly (clang, -O0):
<store_partial_from_left_to_right>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jne    1131 <store_partial_from_left_to_right+0x21>
jmp    11a5 <store_partial_from_left_to_right+0x95>
cmpl   $0x10,-0x10(%rbp)
jb     114c <store_partial_from_left_to_right+0x3c>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <storeu@plt>
jmp    11a0 <store_partial_from_left_to_right+0x90>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
lea    -0xc(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jae    119b <store_partial_from_left_to_right+0x8b>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    $0x10,%ecx
sub    -0x10(%rbp),%ecx
add    -0x14(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1163 <store_partial_from_left_to_right+0x53>
jmp    11a0 <store_partial_from_left_to_right+0x90>
jmp    11a5 <store_partial_from_left_to_right+0x95>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<store_partial_from_left_to_right>:
push   %r14
push   %rbx
mov    %esi,-0x4(%rsp)
test   %edx,%edx
je     121b <store_partial_from_left_to_right+0x10b>
cmp    $0x10,%edx
jb     112c <store_partial_from_left_to_right+0x1c>
pop    %rbx
pop    %r14
jmp    1030 <storeu@plt>
mov    %edx,%r10d
mov    $0x10,%r9d
sub    %r10,%r9
mov    %sil,(%rdi,%r9,1)
cmp    $0x1,%edx
je     121b <store_partial_from_left_to_right+0x10b>
lea    -0x1(%r10),%r8
mov    $0x1,%ecx
cmp    $0x8,%r8
jae    121f <store_partial_from_left_to_right+0x10f>
mov    %r10d,%esi
sub    %ecx,%esi
mov    %rcx,%r8
not    %r8
add    %r10,%r8
and    $0x3,%rsi
je     1196 <store_partial_from_left_to_right+0x86>
mov    $0x10,%r9d
sub    %edx,%r9d
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x4(%rsp,%rcx,1),%eax
lea    (%r9,%rcx,1),%ebx
mov    %al,(%rdi,%rbx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1180 <store_partial_from_left_to_right+0x70>
cmp    $0x3,%r8
jb     121b <store_partial_from_left_to_right+0x10b>
mov    $0x13,%r8d
sub    %edx,%r8d
lea    -0x1(%rsp),%rax
mov    $0x12,%r9d
sub    %edx,%r9d
mov    $0x11,%r11d
sub    %edx,%r11d
mov    $0x10,%esi
sub    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0x3(%rax,%rcx,1),%edx
lea    (%rcx,%rsi,1),%ebx
mov    %dl,(%rdi,%rbx,1)
movzbl -0x2(%rax,%rcx,1),%edx
lea    (%r11,%rcx,1),%ebx
mov    %dl,(%rdi,%rbx,1)
movzbl -0x1(%rax,%rcx,1),%edx
lea    (%r9,%rcx,1),%ebx
mov    %dl,(%rdi,%rbx,1)
movzbl (%rax,%rcx,1),%edx
lea    (%r8,%rcx,1),%ebx
mov    %dl,(%rdi,%rbx,1)
add    $0xfffffffffffffffc,%r10
add    $0x4,%r8
add    $0x4,%rax
add    $0x4,%r9
add    $0x4,%r11
add    $0x4,%rsi
cmp    %r10,%rcx
jne    11d0 <store_partial_from_left_to_right+0xc0>
pop    %rbx
pop    %r14
ret
lea    -0x2(%r10),%rax
lea    -0x12(%rdx),%esi
cmp    %eax,%esi
jb     1158 <store_partial_from_left_to_right+0x48>
shr    $0x20,%rax
jne    1158 <store_partial_from_left_to_right+0x48>
cmp    $0x20,%r8
jae    1245 <store_partial_from_left_to_right+0x135>
xor    %esi,%esi
jmp    12e1 <store_partial_from_left_to_right+0x1d1>
mov    %r8,%rsi
and    $0xffffffffffffffe0,%rsi
lea    -0x20(%rsi),%rax
mov    %rax,%r11
shr    $0x5,%r11
add    $0x1,%r11
test   %rax,%rax
je     12aa <store_partial_from_left_to_right+0x19a>
mov    %r11,%r14
and    $0xfffffffffffffffe,%r14
mov    $0x31,%ebx
sub    %edx,%ebx
xor    %eax,%eax
movups -0x3(%rsp,%rax,1),%xmm0
movups 0xd(%rsp,%rax,1),%xmm1
lea    -0x20(%rbx),%ecx
movups %xmm0,(%rdi,%rcx,1)
movups %xmm1,0x10(%rdi,%rcx,1)
movups 0x1d(%rsp,%rax,1),%xmm0
movups 0x2d(%rsp,%rax,1),%xmm1
mov    %ebx,%ecx
movups %xmm0,(%rdi,%rcx,1)
movups %xmm1,0x10(%rdi,%rcx,1)
add    $0x40,%rax
add    $0x40,%ebx
add    $0xfffffffffffffffe,%r14
jne    1270 <store_partial_from_left_to_right+0x160>
jmp    12ac <store_partial_from_left_to_right+0x19c>
xor    %eax,%eax
test   $0x1,%r11b
je     12d2 <store_partial_from_left_to_right+0x1c2>
mov    %rax,%rcx
or     $0x1,%rcx
or     $0x1,%eax
movups -0x4(%rsp,%rcx,1),%xmm0
movups 0xc(%rsp,%rcx,1),%xmm1
add    %r9d,%eax
movups %xmm0,(%rdi,%rax,1)
movups %xmm1,0x10(%rdi,%rax,1)
cmp    %rsi,%r8
je     121b <store_partial_from_left_to_right+0x10b>
test   $0x18,%r8b
je     1324 <store_partial_from_left_to_right+0x214>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    0x1(%r9),%rcx
mov    $0x11,%r11d
sub    %edx,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x3(%rsp,%rsi,1),%rax
lea    (%r11,%rsi,1),%ebx
mov    %rax,(%rdi,%rbx,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1300 <store_partial_from_left_to_right+0x1f0>
cmp    %r9,%r8
jne    1158 <store_partial_from_left_to_right+0x48>
jmp    121b <store_partial_from_left_to_right+0x10b>
or     $0x1,%rsi
mov    %rsi,%rcx
jmp    1158 <store_partial_from_left_to_right+0x48>

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

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