#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 u_int64_t;
typedef scalar_t__ u_char;
struct sshbuf {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ memcpy(scalar_t__ *, scalar_t__ const *, size_t);
int sshbuf_reserve(struct sshbuf *, size_t, scalar_t__ **);
int sshbuf_put_bignum2_bytes(struct sshbuf *buf, const void *v, size_t len) {
  u_char *d;
  const u_char *s = (const u_char *)v;
  int r, prepend;
  if (len > 0x8000000 - 5) {
    ;
    return -9;
  }
  for (; len > 0 && *s == 0; len--, s++)
    ;
  prepend = len > 0 && (s[0] & 0x80) != 0;
  if ((r = sshbuf_reserve(buf, len + 4 + prepend, &d)) < 0)
    return r;
  do {
    ((u_char *)(d))[0] = (((u_int64_t)(len + prepend)) >> 24) & 0xff;
    ((u_char *)(d))[1] = (((u_int64_t)(len + prepend)) >> 16) & 0xff;
    ((u_char *)(d))[2] = (((u_int64_t)(len + prepend)) >> 8) & 0xff;
    ((u_char *)(d))[3] = ((u_int64_t)(len + prepend)) & 0xff;
  } while (0);
  if (prepend)
    d[4] = 0;
  if (len != 0)
    memcpy(d + 4 + prepend, s, len);
  return 0;
}


x86 assembly (clang, -O0):
<sshbuf_put_bignum2_bytes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x7fffffb,-0x20(%rbp)
07
jbe    1156 <sshbuf_put_bignum2_bytes+0x36>
movl   $0xfffffff7,-0x4(%rbp)
jmp    12d1 <sshbuf_put_bignum2_bytes+0x1b1>
jmp    115b <sshbuf_put_bignum2_bytes+0x3b>
xor    %eax,%eax
cmpq   $0x0,-0x20(%rbp)
mov    %al,-0x39(%rbp)
jbe    1179 <sshbuf_put_bignum2_bytes+0x59>
mov    -0x30(%rbp),%rax
cmpq   $0x0,(%rax)
sete   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1189 <sshbuf_put_bignum2_bytes+0x69>
jmp    11ab <sshbuf_put_bignum2_bytes+0x8b>
jmp    118e <sshbuf_put_bignum2_bytes+0x6e>
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
jmp    115b <sshbuf_put_bignum2_bytes+0x3b>
xor    %eax,%eax
cmpq   $0x0,-0x20(%rbp)
mov    %al,-0x3a(%rbp)
jbe    11d2 <sshbuf_put_bignum2_bytes+0xb2>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
and    $0x80,%rax
cmp    $0x0,%rax
setne  %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
add    $0x4,%rsi
movslq -0x38(%rbp),%rax
add    %rax,%rsi
lea    -0x28(%rbp),%rdx
call   1030 <sshbuf_reserve@plt>
mov    %eax,-0x34(%rbp)
cmp    $0x0,%eax
jge    1210 <sshbuf_put_bignum2_bytes+0xf0>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12d1 <sshbuf_put_bignum2_bytes+0x1b1>
jmp    1215 <sshbuf_put_bignum2_bytes+0xf5>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    %rcx,%rax
sar    $0x18,%eax
and    $0xff,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    %rcx,%rax
sar    $0x10,%eax
and    $0xff,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    %rcx,%rax
sar    $0x8,%eax
and    $0xff,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    %rcx,%rax
and    $0xff,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x18(%rax)
cmpl   $0x0,-0x38(%rbp)
je     129f <sshbuf_put_bignum2_bytes+0x17f>
mov    -0x28(%rbp),%rax
movq   $0x0,0x20(%rax)
cmpq   $0x0,-0x20(%rbp)
je     12ca <sshbuf_put_bignum2_bytes+0x1aa>
mov    -0x28(%rbp),%rdi
add    $0x20,%rdi
movslq -0x38(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1040 <memcpy@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sshbuf_put_bignum2_bytes>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    $0xfffffff7,%ebp
cmp    $0x7fffffb,%rdx
ja     11f4 <sshbuf_put_bignum2_bytes+0xd4>
mov    %rdx,%rbx
mov    %rsi,%r14
mov    $0x1,%r15b
test   %rdx,%rdx
je     1172 <sshbuf_put_bignum2_bytes+0x52>
mov    %r14,%rax
lea    (%r14,%rbx,8),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax),%rcx
test   %rcx,%rcx
jne    1178 <sshbuf_put_bignum2_bytes+0x58>
add    $0x8,%rax
add    $0xffffffffffffffff,%rbx
jne    1160 <sshbuf_put_bignum2_bytes+0x40>
xor    %ebx,%ebx
xor    %ecx,%ecx
jmp    1184 <sshbuf_put_bignum2_bytes+0x64>
movzbl %cl,%ecx
shr    $0x7,%ecx
xor    %r15d,%r15d
mov    %rax,%r14
movzbl %cl,%r12d
lea    (%rbx,%r12,1),%rsi
add    $0x4,%rsi
lea    0x8(%rsp),%rdx
call   1030 <sshbuf_reserve@plt>
test   %eax,%eax
js     11f2 <sshbuf_put_bignum2_bytes+0xd2>
lea    (%rbx,%r12,1),%rax
mov    %eax,%ecx
movzbl %ah,%edx
movzbl %al,%esi
mov    %eax,%edi
shr    $0x18,%edi
mov    0x8(%rsp),%rax
mov    %rdi,(%rax)
shr    $0x10,%ecx
movzbl %cl,%ecx
mov    %rcx,0x8(%rax)
mov    %rdx,0x10(%rax)
mov    %rsi,0x18(%rax)
test   %r12,%r12
je     11d6 <sshbuf_put_bignum2_bytes+0xb6>
movq   $0x0,0x20(%rax)
xor    %ebp,%ebp
test   %r15b,%r15b
jne    11f4 <sshbuf_put_bignum2_bytes+0xd4>
lea    (%rax,%r12,8),%rdi
add    $0x20,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
jmp    11f4 <sshbuf_put_bignum2_bytes+0xd4>
mov    %eax,%ebp
mov    %ebp,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.sshbuf = type { i32 }
define i32 @sshbuf_put_bignum2_bytes(%struct.sshbuf* %0, i8* %1, i64 %2) {
%4 = alloca i64*
%5 = bitcast i64** %4 to i8*
%6 = bitcast i8* %1 to i64*
%7 = icmp ugt i64 %2, 134217723
br i1 %7, label %55, label %8
8: ; preds = %3
%9 = icmp eq i64 %2, 0
br i1 %9, label %26, label %10
10: ; preds = %8
%11 = shl nuw nsw i64 %2, 3
%12 = getelementptr i8, i8* %1, i64 %11
%13 = bitcast i8* %12 to i64*
br label %14
14: ; preds = %10, %19
%15 = phi i64 [ %20, %19 ], [ %2, %10 ]
%16 = phi i64* [ %21, %19 ], [ %6, %10 ]
%17 = load i64, i64* %16
%18 = icmp eq i64 %17, 0
br i1 %18, label %19, label %23
19: ; preds = %14
%20 = add i64 %15, -1
%21 = getelementptr inbounds i64, i64* %16, i64 1
%22 = icmp eq i64 %20, 0
br i1 %22, label %26, label %14
23: ; preds = %14
%24 = and i64 %17, 128
%25 = icmp ne i64 %24, 0
br label %26
26: ; preds = %19, %8, %23
%27 = phi i64* [ %16, %23 ], [ %6, %8 ], [ %13, %19 ]
%28 = phi i64 [ %15, %23 ], [ 0, %8 ], [ 0, %19 ]
%29 = phi i1 [ false, %23 ], [ true, %8 ], [ true, %19 ]
%30 = phi i1 [ %25, %23 ], [ false, %8 ], [ false, %19 ]
%31 = zext i1 %30 to i64
%32 = add i64 %28, %31
%33 = add i64 %32, 4
%34 = call i32 @sshbuf_reserve(%struct.sshbuf* %0, i64 %33, i64** %4)
%35 = icmp slt i32 %34, 0
br i1 %35, label %55, label %36
36: ; preds = %26
%37 = lshr i64 %32, 24
%38 = and i64 %37, 255
%39 = load i64*, i64** %4
store i64 %38, i64* %39
%40 = lshr i64 %32, 16
%41 = and i64 %40, 255
%42 = getelementptr inbounds i64, i64* %39, i64 1
store i64 %41, i64* %42
%43 = lshr i64 %32, 8
%44 = and i64 %43, 255
%45 = getelementptr inbounds i64, i64* %39, i64 2
store i64 %44, i64* %45
%46 = and i64 %32, 255
%47 = getelementptr inbounds i64, i64* %39, i64 3
store i64 %46, i64* %47
br i1 %30, label %48, label %50
48: ; preds = %36
%49 = getelementptr inbounds i64, i64* %39, i64 4
store i64 0, i64* %49
br label %50
50: ; preds = %48, %36
br i1 %29, label %55, label %51
51: ; preds = %50
%52 = getelementptr inbounds i64, i64* %39, i64 4
%53 = getelementptr inbounds i64, i64* %52, i64 %31
%54 = call i32 @memcpy(i64* %53, i64* %27, i64 %28)
br label %55
55: ; preds = %50, %51, %26, %3
%56 = phi i32 [ -9, %3 ], [ %34, %26 ], [ 0, %51 ], [ 0, %50 ]
ret i32 %56
}