#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*/ memcpy(unsigned char *, unsigned char const *, unsigned int);
void pkcs7_generate(unsigned char *output, const unsigned char *input,
                    unsigned int in_len, unsigned int pad_len) {
  unsigned int j;
  unsigned char pad_char = pad_len - (in_len % pad_len);
  memcpy(output, input, in_len * sizeof(char));
  for (j = 0; j < pad_char; j++)
    output[in_len + j] = pad_char;
}


x86 assembly (clang, -O0):
<pkcs7_generate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
xor    %edx,%edx
divl   -0x18(%rbp)
mov    -0x24(%rbp),%eax
sub    %edx,%eax
mov    %al,-0x1d(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%eax
shl    $0x0,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
movzbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jae    1188 <pkcs7_generate+0x78>
mov    -0x1d(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1159 <pkcs7_generate+0x49>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pkcs7_generate>:
push   %rbp
push   %r14
push   %rbx
mov    %ecx,%ebp
mov    %edx,%r14d
mov    %rdi,%rbx
mov    %edx,%eax
xor    %edx,%edx
div    %ecx
sub    %edx,%ebp
mov    %r14d,%edx
call   1030 <memcpy@plt>
mov    %ebp,%edx
and    $0xff,%edx
je     12e8 <pkcs7_generate+0x1d8>
mov    %edx,%r11d
cmp    $0x8,%edx
jae    1149 <pkcs7_generate+0x39>
xor    %ecx,%ecx
jmp    1286 <pkcs7_generate+0x176>
lea    -0x1(%r11),%rax
xor    %ecx,%ecx
mov    %r14d,%esi
add    %eax,%esi
jb     1286 <pkcs7_generate+0x176>
shr    $0x20,%rax
jne    1286 <pkcs7_generate+0x176>
movzbl %bpl,%r8d
cmp    $0x20,%edx
jae    1174 <pkcs7_generate+0x64>
xor    %ecx,%ecx
jmp    1248 <pkcs7_generate+0x138>
mov    %r11d,%ecx
and    $0xe0,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x20(%rcx),%rax
mov    %rax,%r10
shr    $0x5,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x60,%rax
jae    11b0 <pkcs7_generate+0xa0>
xor    %edi,%edi
jmp    1207 <pkcs7_generate+0xf7>
and    $0xfffffffffffffffc,%r10
xor    %edi,%edi
mov    %r14d,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %edx,%eax
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,0x10(%rbx,%rax,1)
lea    0x20(%rdx),%eax
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,0x10(%rbx,%rax,1)
lea    0x40(%rdx),%eax
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,0x10(%rbx,%rax,1)
lea    0x60(%rdx),%eax
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,0x10(%rbx,%rax,1)
sub    $0xffffffffffffff80,%rdi
add    $0x4,%rsi
sub    $0xffffff80,%edx
cmp    %r10,%rsi
jne    11c0 <pkcs7_generate+0xb0>
test   %r9,%r9
je     1239 <pkcs7_generate+0x129>
add    %r14d,%edi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edi,%edx
movdqu %xmm0,(%rbx,%rdx,1)
movdqu %xmm0,0x10(%rbx,%rdx,1)
add    $0x1,%rax
add    $0x20,%edi
cmp    %r9,%rax
jne    1220 <pkcs7_generate+0x110>
cmp    %r11,%rcx
je     12e8 <pkcs7_generate+0x1d8>
test   $0x18,%r11b
je     1286 <pkcs7_generate+0x176>
mov    %rcx,%rdx
mov    %r11d,%ecx
and    $0xf8,%ecx
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
mov    %r14d,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%rdx,1),%esi
movq   %xmm0,(%rbx,%rsi,1)
add    $0x8,%rdx
cmp    %rcx,%rdx
jne    1270 <pkcs7_generate+0x160>
cmp    %r11,%rcx
je     12e8 <pkcs7_generate+0x1d8>
mov    %rcx,%r8
not    %r8
add    %r11,%r8
mov    %r11,%rsi
and    $0x3,%rsi
je     12b4 <pkcs7_generate+0x1a4>
mov    %r14d,%edi
xor    %eax,%eax
nopl   (%rax)
lea    (%rdi,%rcx,1),%edx
mov    %bpl,(%rbx,%rdx,1)
add    $0x1,%rcx
add    $0x1,%rax
cmp    %rsi,%rax
jne    12a0 <pkcs7_generate+0x190>
cmp    $0x3,%r8
jb     12e8 <pkcs7_generate+0x1d8>
mov    %r14d,%edx
nopl   (%rax)
lea    (%rdx,%rcx,1),%rax
mov    %eax,%esi
mov    %bpl,(%rbx,%rsi,1)
lea    0x1(%rax),%esi
mov    %bpl,(%rbx,%rsi,1)
lea    0x2(%rax),%esi
mov    %bpl,(%rbx,%rsi,1)
add    $0x3,%eax
mov    %bpl,(%rbx,%rax,1)
add    $0x4,%rcx
cmp    %r11,%rcx
jne    12c0 <pkcs7_generate+0x1b0>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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