char *re_alloc(ptr, oldsize, newsize)
char *ptr;
unsigned oldsize;
unsigned newsize;
{
  register char *pmem;
  register char *c1, *c2;
  pmem = alloc(newsize, 0);
  if (oldsize) {
    c1 = pmem;
    c2 = ptr;
    if (newsize > oldsize) {
      newsize = oldsize;
    }
    while (newsize--) {
      *c1++ = *c2++;
    }
    free(ptr);
  }
  return pmem;
}


x86 assembly (clang, -O0):
<re_alloc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%edi
xor    %esi,%esi
mov    $0x0,%al
call   1040 <alloc@plt>
cltq
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0xc(%rbp)
je     11b9 <re_alloc+0x99>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jbe    1170 <re_alloc+0x50>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1175 <re_alloc+0x55>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
cmp    $0x0,%eax
je     11b0 <re_alloc+0x90>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    1175 <re_alloc+0x55>
mov    -0x8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<re_alloc>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edx,%r15d
mov    %esi,%ebp
mov    %rdi,%r14
mov    %edx,%edi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <alloc@plt>
movslq %eax,%rbx
test   %ebp,%ebp
je     1226 <re_alloc+0x106>
cmp    %ebp,%r15d
cmova  %ebp,%r15d
test   %r15d,%r15d
je     121e <re_alloc+0xfe>
lea    -0x1(%r15),%r9d
cmp    $0x7,%r9d
jb     1181 <re_alloc+0x61>
lea    (%r14,%r9,1),%rax
add    $0x1,%rax
cmp    %rbx,%rax
jbe    1234 <re_alloc+0x114>
lea    (%rbx,%r9,1),%rax
add    $0x1,%rax
cmp    %r14,%rax
jbe    1234 <re_alloc+0x114>
mov    %r14,%rsi
mov    %rbx,%rdi
lea    -0x1(%r15),%ebp
test   $0x7,%r15b
je     11b8 <re_alloc+0x98>
mov    %r15d,%edx
and    $0x7,%edx
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl (%rsi,%rcx,1),%eax
mov    %al,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %ecx,%edx
jne    11a0 <re_alloc+0x80>
add    %rcx,%rsi
add    %rcx,%rdi
sub    %ecx,%r15d
cmp    $0x7,%ebp
jb     121e <re_alloc+0xfe>
mov    %r15d,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsi,%rcx,1),%edx
mov    %dl,(%rdi,%rcx,1)
movzbl 0x1(%rsi,%rcx,1),%edx
mov    %dl,0x1(%rdi,%rcx,1)
movzbl 0x2(%rsi,%rcx,1),%edx
mov    %dl,0x2(%rdi,%rcx,1)
movzbl 0x3(%rsi,%rcx,1),%edx
mov    %dl,0x3(%rdi,%rcx,1)
movzbl 0x4(%rsi,%rcx,1),%edx
mov    %dl,0x4(%rdi,%rcx,1)
movzbl 0x5(%rsi,%rcx,1),%edx
mov    %dl,0x5(%rdi,%rcx,1)
movzbl 0x6(%rsi,%rcx,1),%edx
mov    %dl,0x6(%rdi,%rcx,1)
movzbl 0x7(%rsi,%rcx,1),%edx
mov    %dl,0x7(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %ecx,%eax
jne    11d0 <re_alloc+0xb0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%rcx
cmp    $0x1f,%r9d
jae    124b <re_alloc+0x12b>
xor    %edx,%edx
jmp    132a <re_alloc+0x20a>
lea    0x1(%r9),%r8
mov    %r8,%rdx
and    %rcx,%rdx
lea    -0x20(%rdx),%rax
mov    %rax,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rax
jae    1273 <re_alloc+0x153>
xor    %esi,%esi
jmp    12e0 <re_alloc+0x1c0>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
movups 0x20(%r14,%rsi,1),%xmm0
movups 0x30(%r14,%rsi,1),%xmm1
movups %xmm0,0x20(%rbx,%rsi,1)
movups %xmm1,0x30(%rbx,%rsi,1)
movups 0x40(%r14,%rsi,1),%xmm0
movups 0x50(%r14,%rsi,1),%xmm1
movups %xmm0,0x40(%rbx,%rsi,1)
movups %xmm1,0x50(%rbx,%rsi,1)
movups 0x60(%r14,%rsi,1),%xmm0
movups 0x70(%r14,%rsi,1),%xmm1
movups %xmm0,0x60(%rbx,%rsi,1)
movups %xmm1,0x70(%rbx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1280 <re_alloc+0x160>
test   %rbp,%rbp
je     131b <re_alloc+0x1fb>
lea    (%rbx,%rsi,1),%rdi
add    $0x10,%rdi
add    %r14,%rsi
add    $0x10,%rsi
shl    $0x5,%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rax,1),%xmm0
movups (%rsi,%rax,1),%xmm1
movups %xmm0,-0x10(%rdi,%rax,1)
movups %xmm1,(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbp
jne    1300 <re_alloc+0x1e0>
cmp    %rdx,%r8
je     121e <re_alloc+0xfe>
test   $0x18,%r8b
je     135f <re_alloc+0x23f>
add    $0x1,%r9
add    $0x18,%rcx
and    %r9,%rcx
lea    (%r14,%rcx,1),%rsi
lea    (%rbx,%rcx,1),%rdi
sub    %ecx,%r15d
mov    (%r14,%rdx,1),%rax
mov    %rax,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1340 <re_alloc+0x220>
cmp    %rcx,%r9
jne    1187 <re_alloc+0x67>
jmp    121e <re_alloc+0xfe>
sub    %edx,%r15d
lea    (%rbx,%rdx,1),%rdi
add    %r14,%rdx
mov    %rdx,%rsi
jmp    1187 <re_alloc+0x67>

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

LLVM IR (-O2):
define i8* @re_alloc(i8* nocapture %0, i32 %1, i32 %2) {
%4 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @alloc to i32 (i32, i32, ...)*)(i32 %2, i32 0)
%5 = sext i32 %4 to i64
%6 = inttoptr i64 %5 to i8*
%7 = icmp eq i32 %1, 0
br i1 %7, label %189, label %8
8: ; preds = %3
%9 = icmp ugt i32 %2, %1
%10 = select i1 %9, i32 %1, i32 %2
%11 = icmp eq i32 %10, 0
br i1 %11, label %188, label %12
12: ; preds = %8
%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 %135, 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* %6, i64 %20
%22 = getelementptr i8, i8* %0, i64 %20
%23 = icmp ugt i8* %22, %6
%24 = icmp ugt i8* %21, %0
%25 = and i1 %23, %24
br i1 %25, label %135, label %26
26: ; preds = %17
%27 = icmp ult i32 %13, 31
br i1 %27, label %114, 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* %0, i64 %38
%41 = getelementptr i8, i8* %6, 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* %0, i64 %50
%52 = getelementptr i8, i8* %6, 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* %0, i64 %61
%63 = getelementptr i8, i8* %6, 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* %0, i64 %72
%74 = getelementptr i8, i8* %6, 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* %0, i64 %90
%93 = getelementptr i8, i8* %6, 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 = sub i32 %10, %108
%110 = getelementptr i8, i8* %6, i64 %29
%111 = getelementptr i8, i8* %0, i64 %29
%112 = and i64 %15, 24
%113 = icmp eq i64 %112, 0
br i1 %113, label %135, label %114
114: ; preds = %26, %107
%115 = phi i64 [ %29, %107 ], [ 0, %26 ]
%116 = add i32 %10, -1
%117 = zext i32 %116 to i64
%118 = add nuw nsw i64 %117, 1
%119 = and i64 %118, 8589934584
%120 = getelementptr i8, i8* %0, i64 %119
%121 = getelementptr i8, i8* %6, i64 %119
%122 = trunc i64 %119 to i32
%123 = sub i32 %10, %122
br label %124
124: ; preds = %124, %114
%125 = phi i64 [ %115, %114 ], [ %131, %124 ]
%126 = getelementptr i8, i8* %0, i64 %125
%127 = getelementptr i8, i8* %6, i64 %125
%128 = bitcast i8* %126 to <8 x i8>*
%129 = load <8 x i8>, <8 x i8>* %128
%130 = bitcast i8* %127 to <8 x i8>*
store <8 x i8> %129, <8 x i8>* %130
%131 = add nuw i64 %125, 8
%132 = icmp eq i64 %131, %119
br i1 %132, label %133, label %124
133: ; preds = %124
%134 = icmp eq i64 %118, %119
br i1 %134, label %188, label %135
135: ; preds = %17, %12, %107, %133
%136 = phi i8* [ %0, %12 ], [ %0, %17 ], [ %111, %107 ], [ %120, %133 ]
%137 = phi i8* [ %6, %12 ], [ %6, %17 ], [ %110, %107 ], [ %121, %133 ]
%138 = phi i32 [ %10, %12 ], [ %10, %17 ], [ %109, %107 ], [ %123, %133 ]
%139 = add i32 %138, -1
%140 = and i32 %138, 7
%141 = icmp eq i32 %140, 0
br i1 %141, label %153, label %142
142: ; preds = %135, %142
%143 = phi i8* [ %148, %142 ], [ %136, %135 ]
%144 = phi i8* [ %150, %142 ], [ %137, %135 ]
%145 = phi i32 [ %147, %142 ], [ %138, %135 ]
%146 = phi i32 [ %151, %142 ], [ 0, %135 ]
%147 = add i32 %145, -1
%148 = getelementptr inbounds i8, i8* %143, i64 1
%149 = load i8, i8* %143
%150 = getelementptr inbounds i8, i8* %144, i64 1
store i8 %149, i8* %144
%151 = add i32 %146, 1
%152 = icmp eq i32 %151, %140
br i1 %152, label %153, label %142
153: ; preds = %142, %135
%154 = phi i8* [ %136, %135 ], [ %148, %142 ]
%155 = phi i8* [ %137, %135 ], [ %150, %142 ]
%156 = phi i32 [ %138, %135 ], [ %147, %142 ]
%157 = icmp ult i32 %139, 7
br i1 %157, label %188, label %158
158: ; preds = %153, %158
%159 = phi i8* [ %184, %158 ], [ %154, %153 ]
%160 = phi i8* [ %186, %158 ], [ %155, %153 ]
%161 = phi i32 [ %183, %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 = add i32 %161, -8
%184 = getelementptr inbounds i8, i8* %159, i64 8
%185 = load i8, i8* %180
%186 = getelementptr inbounds i8, i8* %160, i64 8
store i8 %185, i8* %182
%187 = icmp eq i32 %183, 0
br i1 %187, label %188, label %158
188: ; preds = %153, %158, %105, %133, %8
tail call void @free(i8* %0)
br label %189
189: ; preds = %188, %3
ret i8* %6
}