#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 */
scalar_t__ malloc(int);
void encrypt_str(const size_t *public_key, const size_t public_key_size,
                 const size_t *str, const size_t str_size,
                 size_t **encrypted_str, size_t *encrypted_str_size) {
  size_t m = str_size % public_key_size;
  size_t size = str_size / public_key_size;
  if (m > 0) {
    size++;
  }
  size_t *p = (size_t *)malloc((sizeof *encrypted_str) * size);
  size_t i = 0;
  size_t sum = 0;
  size_t k = 0;
  if (m > 0) {
    for (; i < m; i++) {
      if (str[i] != 0) {
        sum += public_key[public_key_size - m + i];
      }
    }
    p[k] = sum;
    k++;
  }
  size_t j = 0;
  for (; i < str_size; i += public_key_size, k++) {
    sum = 0;
    j = 0;
    for (; j < public_key_size; j++) {
      if (str[i + j] != 0) {
        sum += public_key[j];
      }
      p[k] = sum;
    }
  }
  *encrypted_str = (size_t *)p;
  *encrypted_str_size = size;
}


x86 assembly (clang, -O0):
<encrypt_str>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10(%rbp)
mov    %rdx,-0x38(%rbp)
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x10(%rbp)
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x38(%rbp)
jbe    1167 <encrypt_str+0x57>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
cmpq   $0x0,-0x38(%rbp)
jbe    1211 <encrypt_str+0x101>
jmp    11a2 <encrypt_str+0x92>
mov    -0x50(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    11f5 <encrypt_str+0xe5>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     11df <encrypt_str+0xcf>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    -0x38(%rbp),%rcx
add    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    11e4 <encrypt_str+0xd4>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    11a2 <encrypt_str+0x92>
mov    -0x58(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    12b3 <encrypt_str+0x1a3>
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1291 <encrypt_str+0x181>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x68(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1270 <encrypt_str+0x160>
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1237 <encrypt_str+0x127>
jmp    1296 <encrypt_str+0x186>
mov    -0x10(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1219 <encrypt_str+0x109>
mov    -0x48(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encrypt_str>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%r15
mov    %rdi,%r14
mov    %rcx,%rax
or     %rsi,%rax
shr    $0x20,%rax
mov    %r8,0x8(%rsp)
mov    %r9,%rbp
je     114b <encrypt_str+0x3b>
mov    %r12,%rax
xor    %edx,%edx
div    %r15
mov    %rdx,%rbx
jmp    1155 <encrypt_str+0x45>
mov    %r12d,%eax
xor    %edx,%edx
div    %r15d
mov    %edx,%ebx
xor    %ecx,%ecx
test   %rbx,%rbx
setne  %cl
add    %rax,%rcx
mov    %rcx,0x10(%rsp)
lea    0x0(,%rcx,8),%edi
call   1030 <malloc@plt>
test   %rbx,%rbx
je     11bd <encrypt_str+0xad>
mov    %r15,%rsi
sub    %rbx,%rsi
cmp    $0x1,%rbx
jne    1275 <encrypt_str+0x165>
xor    %edx,%edx
xor    %r9d,%r9d
mov    %rbp,%r10
mov    0x8(%rsp),%r11
test   $0x1,%bl
je     11ab <encrypt_str+0x9b>
cmpq   $0x0,0x0(%r13,%r9,8)
je     11a7 <encrypt_str+0x97>
add    %r9,%rsi
add    (%r14,%rsi,8),%rdx
add    $0x1,%r9
mov    %rdx,(%rax)
mov    $0x1,%edx
cmp    %r12,%r9
jb     11d3 <encrypt_str+0xc3>
jmp    125b <encrypt_str+0x14b>
xor    %r9d,%r9d
xor    %edx,%edx
mov    %rbp,%r10
mov    0x8(%rsp),%r11
cmp    %r12,%r9
jae    125b <encrypt_str+0x14b>
mov    %r15,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x8(,%r9,8),%rdi
add    %r13,%rdi
lea    0x0(,%r15,8),%r8
jmp    1203 <encrypt_str+0xf3>
nop
mov    %rbx,(%rax,%rdx,8)
add    %r15,%r9
add    $0x1,%rdx
add    %r8,%rdi
cmp    %r12,%r9
jae    125b <encrypt_str+0x14b>
test   %r15,%r15
je     11f4 <encrypt_str+0xe4>
xor    %ebp,%ebp
xor    %ebx,%ebx
cmp    $0x1,%r15
jne    123d <encrypt_str+0x12d>
test   $0x1,%r15b
je     11f4 <encrypt_str+0xe4>
lea    (%r9,%rbp,1),%rcx
cmpq   $0x0,0x0(%r13,%rcx,8)
je     11f0 <encrypt_str+0xe0>
add    (%r14,%rbp,8),%rbx
jmp    11f0 <encrypt_str+0xe0>
nopw   0x0(%rax,%rax,1)
mov    %rbx,(%rax,%rdx,8)
add    $0x2,%rbp
cmp    %rbp,%rsi
je     1212 <encrypt_str+0x102>
cmpq   $0x0,-0x8(%rdi,%rbp,8)
je     1249 <encrypt_str+0x139>
add    (%r14,%rbp,8),%rbx
mov    %rbx,(%rax,%rdx,8)
cmpq   $0x0,(%rdi,%rbp,8)
je     1230 <encrypt_str+0x120>
add    0x8(%r14,%rbp,8),%rbx
jmp    1230 <encrypt_str+0x120>
mov    %rax,(%r11)
mov    0x10(%rsp),%rax
mov    %rax,(%r10)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xor    %r9d,%r9d
mov    %rbp,%r10
mov    0x8(%rsp),%r11
jmp    129d <encrypt_str+0x18d>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r9
cmp    %rdi,%r9
je     1193 <encrypt_str+0x83>
cmpq   $0x0,0x0(%r13,%r9,8)
je     12ad <encrypt_str+0x19d>
lea    (%rsi,%r9,1),%rbp
add    (%r14,%rbp,8),%rdx
cmpq   $0x0,0x8(%r13,%r9,8)
je     1290 <encrypt_str+0x180>
mov    %r9,%rcx
or     $0x1,%rcx
add    %rsi,%rcx
add    (%r14,%rcx,8),%rdx
jmp    1290 <encrypt_str+0x180>

LLVM IR (-O0):
define void @encrypt_str(i64* %0, i64 %1, i64* %2, i64 %3, i64** %4, i64* %5) {
%7 = alloca i64*
%8 = alloca i64
%9 = alloca i64*
%10 = alloca i64
%11 = alloca i64**
%12 = alloca i64*
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64*
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
store i64* %0, i64** %7
store i64 %1, i64* %8
store i64* %2, i64** %9
store i64 %3, i64* %10
store i64** %4, i64*** %11
store i64* %5, i64** %12
%20 = load i64, i64* %10
%21 = load i64, i64* %8
%22 = urem i64 %20, %21
store i64 %22, i64* %13
%23 = load i64, i64* %10
%24 = load i64, i64* %8
%25 = udiv i64 %23, %24
store i64 %25, i64* %14
%26 = load i64, i64* %13
%27 = icmp ugt i64 %26, 0
br i1 %27, label %28, label %31
28: ; preds = %6
%29 = load i64, i64* %14
%30 = add i64 %29, 1
store i64 %30, i64* %14
br label %31
31: ; preds = %28, %6
%32 = load i64, i64* %14
%33 = mul i64 8, %32
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to i64*
store i64* %36, i64** %15
store i64 0, i64* %16
store i64 0, i64* %17
store i64 0, i64* %18
%37 = load i64, i64* %13
%38 = icmp ugt i64 %37, 0
br i1 %38, label %39, label %72
39: ; preds = %31
br label %40
40: ; preds = %62, %39
%41 = load i64, i64* %16
%42 = load i64, i64* %13
%43 = icmp ult i64 %41, %42
br i1 %43, label %44, label %65
44: ; preds = %40
%45 = load i64*, i64** %9
%46 = load i64, i64* %16
%47 = getelementptr inbounds i64, i64* %45, i64 %46
%48 = load i64, i64* %47
%49 = icmp ne i64 %48, 0
br i1 %49, label %50, label %61
50: ; preds = %44
%51 = load i64*, i64** %7
%52 = load i64, i64* %8
%53 = load i64, i64* %13
%54 = sub i64 %52, %53
%55 = load i64, i64* %16
%56 = add i64 %54, %55
%57 = getelementptr inbounds i64, i64* %51, i64 %56
%58 = load i64, i64* %57
%59 = load i64, i64* %17
%60 = add i64 %59, %58
store i64 %60, i64* %17
br label %61
61: ; preds = %50, %44
br label %62
62: ; preds = %61
%63 = load i64, i64* %16
%64 = add i64 %63, 1
store i64 %64, i64* %16
br label %40
65: ; preds = %40
%66 = load i64, i64* %17
%67 = load i64*, i64** %15
%68 = load i64, i64* %18
%69 = getelementptr inbounds i64, i64* %67, i64 %68
store i64 %66, i64* %69
%70 = load i64, i64* %18
%71 = add i64 %70, 1
store i64 %71, i64* %18
br label %72
72: ; preds = %65, %31
store i64 0, i64* %19
br label %73
73: ; preds = %106, %72
%74 = load i64, i64* %16
%75 = load i64, i64* %10
%76 = icmp ult i64 %74, %75
br i1 %76, label %77, label %112
77: ; preds = %73
store i64 0, i64* %17
store i64 0, i64* %19
br label %78
78: ; preds = %102, %77
%79 = load i64, i64* %19
%80 = load i64, i64* %8
%81 = icmp ult i64 %79, %80
br i1 %81, label %82, label %105
82: ; preds = %78
%83 = load i64*, i64** %9
%84 = load i64, i64* %16
%85 = load i64, i64* %19
%86 = add i64 %84, %85
%87 = getelementptr inbounds i64, i64* %83, i64 %86
%88 = load i64, i64* %87
%89 = icmp ne i64 %88, 0
br i1 %89, label %90, label %97
90: ; preds = %82
%91 = load i64*, i64** %7
%92 = load i64, i64* %19
%93 = getelementptr inbounds i64, i64* %91, i64 %92
%94 = load i64, i64* %93
%95 = load i64, i64* %17
%96 = add i64 %95, %94
store i64 %96, i64* %17
br label %97
97: ; preds = %90, %82
%98 = load i64, i64* %17
%99 = load i64*, i64** %15
%100 = load i64, i64* %18
%101 = getelementptr inbounds i64, i64* %99, i64 %100
store i64 %98, i64* %101
br label %102
102: ; preds = %97
%103 = load i64, i64* %19
%104 = add i64 %103, 1
store i64 %104, i64* %19
br label %78
105: ; preds = %78
br label %106
106: ; preds = %105
%107 = load i64, i64* %8
%108 = load i64, i64* %16
%109 = add i64 %108, %107
store i64 %109, i64* %16
%110 = load i64, i64* %18
%111 = add i64 %110, 1
store i64 %111, i64* %18
br label %73
112: ; preds = %73
%113 = load i64*, i64** %15
%114 = load i64**, i64*** %11
store i64* %113, i64** %114
%115 = load i64, i64* %14
%116 = load i64*, i64** %12
store i64 %115, i64* %116
ret void
}

LLVM IR (-O2):
define void @encrypt_str(i64* nocapture %0, i64 %1, i64* nocapture %2, i64 %3, i64** nocapture writeonly %4, i64* nocapture writeonly %5) {
%7 = urem i64 %3, %1
%8 = udiv i64 %3, %1
%9 = urem i64 %3, %1
%10 = icmp eq i64 %7, 0
%11 = xor i1 %10, true
%12 = zext i1 %11 to i64
%13 = add i64 %8, %12
%14 = trunc i64 %13 to i32
%15 = shl i32 %14, 3
%16 = tail call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to i64*
br i1 %10, label %73, label %18
18: ; preds = %6
%19 = sub i64 %1, %7
%20 = and i64 %7, 1
%21 = icmp eq i64 %9, 1
br i1 %21, label %52, label %22
22: ; preds = %18
%23 = and i64 %7, -2
br label %24
24: ; preds = %47, %22
%25 = phi i64 [ 0, %22 ], [ %48, %47 ]
%26 = phi i64 [ 0, %22 ], [ %49, %47 ]
%27 = phi i64 [ 0, %22 ], [ %50, %47 ]
%28 = getelementptr inbounds i64, i64* %2, i64 %26
%29 = load i64, i64* %28
%30 = icmp eq i64 %29, 0
br i1 %30, label %36, label %31
31: ; preds = %24
%32 = add i64 %19, %26
%33 = getelementptr inbounds i64, i64* %0, i64 %32
%34 = load i64, i64* %33
%35 = add i64 %34, %25
br label %36
36: ; preds = %24, %31
%37 = phi i64 [ %35, %31 ], [ %25, %24 ]
%38 = or i64 %26, 1
%39 = getelementptr inbounds i64, i64* %2, i64 %38
%40 = load i64, i64* %39
%41 = icmp eq i64 %40, 0
br i1 %41, label %47, label %42
42: ; preds = %36
%43 = add i64 %19, %38
%44 = getelementptr inbounds i64, i64* %0, i64 %43
%45 = load i64, i64* %44
%46 = add i64 %45, %37
br label %47
47: ; preds = %42, %36
%48 = phi i64 [ %46, %42 ], [ %37, %36 ]
%49 = add nuw i64 %26, 2
%50 = add i64 %27, 2
%51 = icmp eq i64 %50, %23
br i1 %51, label %52, label %24
52: ; preds = %47, %18
%53 = phi i64 [ undef, %18 ], [ %48, %47 ]
%54 = phi i64 [ undef, %18 ], [ %49, %47 ]
%55 = phi i64 [ 0, %18 ], [ %48, %47 ]
%56 = phi i64 [ 0, %18 ], [ %49, %47 ]
%57 = icmp eq i64 %20, 0
br i1 %57, label %70, label %58
58: ; preds = %52
%59 = getelementptr inbounds i64, i64* %2, i64 %56
%60 = load i64, i64* %59
%61 = icmp eq i64 %60, 0
br i1 %61, label %67, label %62
62: ; preds = %58
%63 = add i64 %19, %56
%64 = getelementptr inbounds i64, i64* %0, i64 %63
%65 = load i64, i64* %64
%66 = add i64 %65, %55
br label %67
67: ; preds = %62, %58
%68 = phi i64 [ %66, %62 ], [ %55, %58 ]
%69 = add nuw i64 %56, 1
br label %70
70: ; preds = %52, %67
%71 = phi i64 [ %53, %52 ], [ %68, %67 ]
%72 = phi i64 [ %54, %52 ], [ %69, %67 ]
store i64 %71, i64* %17
br label %73
73: ; preds = %70, %6
%74 = phi i64 [ %72, %70 ], [ 0, %6 ]
%75 = phi i64 [ 1, %70 ], [ 0, %6 ]
%76 = icmp ult i64 %74, %3
br i1 %76, label %77, label %134
77: ; preds = %73
%78 = icmp eq i64 %1, 0
%79 = and i64 %1, 1
%80 = icmp eq i64 %1, 1
%81 = and i64 %1, -2
%82 = icmp eq i64 %79, 0
br label %83
83: ; preds = %77, %130
%84 = phi i64 [ %75, %77 ], [ %132, %130 ]
%85 = phi i64 [ %74, %77 ], [ %131, %130 ]
br i1 %78, label %130, label %86
86: ; preds = %83
%87 = getelementptr inbounds i64, i64* %17, i64 %84
br i1 %80, label %116, label %88
88: ; preds = %86, %111
%89 = phi i64 [ %113, %111 ], [ 0, %86 ]
%90 = phi i64 [ %112, %111 ], [ 0, %86 ]
%91 = phi i64 [ %114, %111 ], [ 0, %86 ]
%92 = add i64 %89, %85
%93 = getelementptr inbounds i64, i64* %2, i64 %92
%94 = load i64, i64* %93
%95 = icmp eq i64 %94, 0
br i1 %95, label %100, label %96
96: ; preds = %88
%97 = getelementptr inbounds i64, i64* %0, i64 %89
%98 = load i64, i64* %97
%99 = add i64 %98, %90
br label %100
100: ; preds = %96, %88
%101 = phi i64 [ %99, %96 ], [ %90, %88 ]
store i64 %101, i64* %87
%102 = or i64 %89, 1
%103 = add i64 %102, %85
%104 = getelementptr inbounds i64, i64* %2, i64 %103
%105 = load i64, i64* %104
%106 = icmp eq i64 %105, 0
br i1 %106, label %111, label %107
107: ; preds = %100
%108 = getelementptr inbounds i64, i64* %0, i64 %102
%109 = load i64, i64* %108
%110 = add i64 %109, %101
br label %111
111: ; preds = %107, %100
%112 = phi i64 [ %110, %107 ], [ %101, %100 ]
store i64 %112, i64* %87
%113 = add nuw i64 %89, 2
%114 = add i64 %91, 2
%115 = icmp eq i64 %114, %81
br i1 %115, label %116, label %88
116: ; preds = %111, %86
%117 = phi i64 [ 0, %86 ], [ %113, %111 ]
%118 = phi i64 [ 0, %86 ], [ %112, %111 ]
br i1 %82, label %130, label %119
119: ; preds = %116
%120 = add i64 %117, %85
%121 = getelementptr inbounds i64, i64* %2, i64 %120
%122 = load i64, i64* %121
%123 = icmp eq i64 %122, 0
br i1 %123, label %128, label %124
124: ; preds = %119
%125 = getelementptr inbounds i64, i64* %0, i64 %117
%126 = load i64, i64* %125
%127 = add i64 %126, %118
br label %128
128: ; preds = %124, %119
%129 = phi i64 [ %127, %124 ], [ %118, %119 ]
store i64 %129, i64* %87
br label %130
130: ; preds = %128, %116, %83
%131 = add i64 %85, %1
%132 = add i64 %84, 1
%133 = icmp ult i64 %131, %3
br i1 %133, label %83, label %134
134: ; preds = %130, %73
store i64* %17, i64** %4
store i64 %13, i64* %5
ret void
}