#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*/ free(char *);
scalar_t__ malloc(int);
int reset(char **p, int size, int new_size) {
  int ret = 1;
  int i = 0;
  int len = 0;
  char *pt = NULL;
  char *tmp = NULL;
  char *pp = *p;
  if (NULL != p && 0 < new_size) {
    pt = (char *)malloc(new_size);
    tmp = pt;
    len = (size < new_size) ? size : new_size;
    for (i = 0; i < len; i++)
      *tmp++ = *pp++;
    free(*p);
    *p = pt;
  } else
    ret = 0;
  return ret;
}


x86 assembly (clang, -O0):
<reset>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
je     120f <reset+0xef>
xor    %eax,%eax
cmp    -0x10(%rbp),%eax
jge    120f <reset+0xef>
mov    -0x10(%rbp),%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11a4 <reset+0x84>
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    11aa <reset+0x8a>
mov    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f3 <reset+0xd3>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b7 <reset+0x97>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
jmp    1216 <reset+0xf6>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reset>:
test   %edx,%edx
jle    1238 <reset+0x118>
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r12d
mov    %esi,%ebp
mov    %rdi,%r14
mov    (%rdi),%rbx
mov    %edx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
cmp    %r12d,%ebp
cmovl  %ebp,%r12d
test   %r12d,%r12d
jle    121f <reset+0xff>
lea    -0x1(%r12),%r9d
xor    %eax,%eax
cmp    $0x7,%r9d
jb     1184 <reset+0x64>
lea    (%rbx,%r9,1),%rcx
add    $0x1,%rcx
cmp    %r15,%rcx
jbe    123b <reset+0x11b>
lea    (%r15,%r9,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rbx
jae    123b <reset+0x11b>
mov    %rbx,%rsi
mov    %r15,%rdx
mov    %r12d,%edi
sub    %eax,%edi
mov    %eax,%ecx
not    %ecx
add    %r12d,%ecx
and    $0x7,%edi
je     11b7 <reset+0x97>
neg    %edi
xor    %ebp,%ebp
nop
movzbl (%rsi),%ebx
add    $0x1,%rsi
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edi
jne    11a0 <reset+0x80>
sub    %ebp,%eax
cmp    $0x7,%ecx
jb     121f <reset+0xff>
sub    %eax,%r12d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rax,1),%ecx
mov    %cl,(%rdx,%rax,1)
movzbl 0x1(%rsi,%rax,1),%ecx
mov    %cl,0x1(%rdx,%rax,1)
movzbl 0x2(%rsi,%rax,1),%ecx
mov    %cl,0x2(%rdx,%rax,1)
movzbl 0x3(%rsi,%rax,1),%ecx
mov    %cl,0x3(%rdx,%rax,1)
movzbl 0x4(%rsi,%rax,1),%ecx
mov    %cl,0x4(%rdx,%rax,1)
movzbl 0x5(%rsi,%rax,1),%ecx
mov    %cl,0x5(%rdx,%rax,1)
movzbl 0x6(%rsi,%rax,1),%ecx
mov    %cl,0x6(%rdx,%rax,1)
movzbl 0x7(%rsi,%rax,1),%ecx
mov    %cl,0x7(%rdx,%rax,1)
add    $0x8,%rax
cmp    %eax,%r12d
jne    11d0 <reset+0xb0>
mov    (%r14),%rdi
call   1030 <free@plt>
mov    %r15,(%r14)
mov    $0x1,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
ret
movabs $0x1ffffffe0,%rax
cmp    $0x1f,%r9d
jae    1252 <reset+0x132>
xor    %edi,%edi
jmp    132a <reset+0x20a>
lea    0x1(%r9),%r8
mov    %r8,%rdi
and    %rax,%rdi
lea    -0x20(%rdi),%rcx
mov    %rcx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rcx
jae    127a <reset+0x15a>
xor    %edx,%edx
jmp    12e0 <reset+0x1c0>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
movups (%rbx,%rdx,1),%xmm0
movups 0x10(%rbx,%rdx,1),%xmm1
movups %xmm0,(%r15,%rdx,1)
movups %xmm1,0x10(%r15,%rdx,1)
movups 0x20(%rbx,%rdx,1),%xmm0
movups 0x30(%rbx,%rdx,1),%xmm1
movups %xmm0,0x20(%r15,%rdx,1)
movups %xmm1,0x30(%r15,%rdx,1)
movups 0x40(%rbx,%rdx,1),%xmm0
movups 0x50(%rbx,%rdx,1),%xmm1
movups %xmm0,0x40(%r15,%rdx,1)
movups %xmm1,0x50(%r15,%rdx,1)
movups 0x60(%rbx,%rdx,1),%xmm0
movups 0x70(%rbx,%rdx,1),%xmm1
movups %xmm0,0x60(%r15,%rdx,1)
movups %xmm1,0x70(%r15,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1280 <reset+0x160>
test   %rbp,%rbp
je     131b <reset+0x1fb>
lea    (%r15,%rdx,1),%rsi
add    $0x10,%rsi
add    %rbx,%rdx
add    $0x10,%rdx
shl    $0x5,%rbp
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rcx,1),%xmm0
movups (%rdx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rcx,1)
movups %xmm1,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rbp
jne    1300 <reset+0x1e0>
cmp    %rdi,%r8
je     121f <reset+0xff>
test   $0x18,%r8b
je     135f <reset+0x23f>
add    $0x1,%r9
add    $0x18,%rax
and    %r9,%rax
lea    (%rbx,%rax,1),%rsi
mov    %r15,%rdx
add    %rax,%rdx
nop
mov    (%rbx,%rdi,1),%rcx
mov    %rcx,(%r15,%rdi,1)
add    $0x8,%rdi
cmp    %rdi,%rax
jne    1340 <reset+0x220>
cmp    %rax,%r9
jne    118a <reset+0x6a>
jmp    121f <reset+0xff>
mov    %r15,%rdx
add    %rdi,%rdx
add    %rdi,%rbx
mov    %rbx,%rsi
mov    %edi,%eax
jmp    118a <reset+0x6a>

LLVM IR (-O0):
define i32 @reset(i8** %0, i32 %1, i32 %2) {
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8*
store i8** %0, i8*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 1, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
store i8* null, i8** %10
store i8* null, i8** %11
%13 = load i8**, i8*** %4
%14 = load i8*, i8** %13
store i8* %14, i8** %12
%15 = load i8**, i8*** %4
%16 = icmp ne i8** null, %15
br i1 %16, label %17, label %53
17: ; preds = %3
%18 = load i32, i32* %6
%19 = icmp slt i32 0, %18
br i1 %19, label %20, label %53
20: ; preds = %17
%21 = load i32, i32* %6
%22 = call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to i8*
store i8* %23, i8** %10
%24 = load i8*, i8** %10
store i8* %24, i8** %11
%25 = load i32, i32* %5
%26 = load i32, i32* %6
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %30
28: ; preds = %20
%29 = load i32, i32* %5
br label %32
30: ; preds = %20
%31 = load i32, i32* %6
br label %32
32: ; preds = %30, %28
%33 = phi i32 [ %29, %28 ], [ %31, %30 ]
store i32 %33, i32* %9
store i32 0, i32* %8
br label %34
34: ; preds = %44, %32
%35 = load i32, i32* %8
%36 = load i32, i32* %9
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %47
38: ; preds = %34
%39 = load i8*, i8** %12
%40 = getelementptr inbounds i8, i8* %39, i32 1
store i8* %40, i8** %12
%41 = load i8, i8* %39
%42 = load i8*, i8** %11
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %11
store i8 %41, i8* %42
br label %44
44: ; preds = %38
%45 = load i32, i32* %8
%46 = add nsw i32 %45, 1
store i32 %46, i32* %8
br label %34
47: ; preds = %34
%48 = load i8**, i8*** %4
%49 = load i8*, i8** %48
%50 = call i32 @free(i8* %49)
%51 = load i8*, i8** %10
%52 = load i8**, i8*** %4
store i8* %51, i8** %52
br label %54
53: ; preds = %17, %3
store i32 0, i32* %7
br label %54
54: ; preds = %53, %47
%55 = load i32, i32* %7
ret i32 %55
}

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