#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(char *, char *, size_t);
size_t sdslen(char *);
size_t strlen(char *);
int genericMemcachedCommand(int cmdtype, char *cmd, int argtype, int argc,
                            char **argv, size_t *argvlen) {
  int j;
  size_t len;
  int pos = 0;
  switch (cmdtype) {
  case 1:
  case 2:
    for (j = 0; j < argc - 1; j++) {
      len = (argtype == 0 ? sdslen(argv[j])
                          : (argvlen == NULL ? strlen(argv[j]) : argvlen[j]));
      memcpy(cmd + pos, argv[j], len);
      pos += (int)len;
      cmd[pos++] = ' ';
    }
    cmd[pos++] = '\r';
    cmd[pos++] = '\n';
    len = (argtype == 0 ? sdslen(argv[argc - 1])
                        : (argvlen == NULL ? strlen(argv[argc - 1])
                                           : argvlen[argc - 1]));
    memcpy(cmd + pos, argv[argc - 1], len);
    pos += (int)len;
    cmd[pos++] = '\r';
    cmd[pos++] = '\n';
    break;
  case 4:
  case 3:
  case 5:
    for (j = 0; j < argc - 1; j++) {
      len = (argtype == 0 ? sdslen(argv[j])
                          : (argvlen == NULL ? strlen(argv[j]) : argvlen[j]));
      memcpy(cmd + pos, argv[j], len);
      pos += len;
      cmd[pos++] = ' ';
    }
    len = (argtype == 0 ? sdslen(argv[argc - 1])
                        : (argvlen == NULL ? strlen(argv[argc - 1])
                                           : argvlen[argc - 1]));
    memcpy(cmd + pos, argv[argc - 1], len);
    pos += (int)len;
    cmd[pos++] = '\r';
    cmd[pos++] = '\n';
    break;
  default:
    pos = -1;
    break;
  }
  return pos;
}


x86 assembly (clang, -O0):
<genericMemcachedCommand>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x40(%rbp)
add    $0xffffffff,%eax
sub    $0x2,%eax
jb     1182 <genericMemcachedCommand+0x52>
jmp    116e <genericMemcachedCommand+0x3e>
mov    -0x40(%rbp),%eax
add    $0xfffffffd,%eax
sub    $0x3,%eax
jb     1355 <genericMemcachedCommand+0x225>
jmp    1500 <genericMemcachedCommand+0x3d0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1251 <genericMemcachedCommand+0x121>
cmpl   $0x0,-0x14(%rbp)
jne    11be <genericMemcachedCommand+0x8e>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,-0x48(%rbp)
jmp    11fb <genericMemcachedCommand+0xcb>
cmpq   $0x0,-0x28(%rbp)
jne    11e3 <genericMemcachedCommand+0xb3>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x50(%rbp)
jmp    11f3 <genericMemcachedCommand+0xc3>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rdx
call   1040 <memcpy@plt>
mov    -0x38(%rbp),%rax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1189 <genericMemcachedCommand+0x59>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
cmpl   $0x0,-0x14(%rbp)
jne    12a6 <genericMemcachedCommand+0x176>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,-0x58(%rbp)
jmp    12ed <genericMemcachedCommand+0x1bd>
cmpq   $0x0,-0x28(%rbp)
jne    12d0 <genericMemcachedCommand+0x1a0>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x60(%rbp)
jmp    12e5 <genericMemcachedCommand+0x1b5>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rdx
call   1040 <memcpy@plt>
mov    -0x38(%rbp),%rax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
jmp    1507 <genericMemcachedCommand+0x3d7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1428 <genericMemcachedCommand+0x2f8>
cmpl   $0x0,-0x14(%rbp)
jne    1391 <genericMemcachedCommand+0x261>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,-0x68(%rbp)
jmp    13ce <genericMemcachedCommand+0x29e>
cmpq   $0x0,-0x28(%rbp)
jne    13b6 <genericMemcachedCommand+0x286>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x70(%rbp)
jmp    13c6 <genericMemcachedCommand+0x296>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rdx
call   1040 <memcpy@plt>
mov    -0x38(%rbp),%rcx
movslq -0x3c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    135c <genericMemcachedCommand+0x22c>
cmpl   $0x0,-0x14(%rbp)
jne    1451 <genericMemcachedCommand+0x321>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,-0x78(%rbp)
jmp    1498 <genericMemcachedCommand+0x368>
cmpq   $0x0,-0x28(%rbp)
jne    147b <genericMemcachedCommand+0x34b>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x80(%rbp)
jmp    1490 <genericMemcachedCommand+0x360>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x3c(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rdx
call   1040 <memcpy@plt>
mov    -0x38(%rbp),%rax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
jmp    1507 <genericMemcachedCommand+0x3d7>
movl   $0xffffffff,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genericMemcachedCommand>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%r14
mov    %edx,(%rsp)
mov    %rsi,%r13
lea    -0x3(%rdi),%eax
cmp    $0x3,%eax
mov    %r9,0x10(%rsp)
jae    11eb <genericMemcachedCommand+0xbb>
lea    -0x1(%rcx),%eax
mov    %eax,0x8(%rsp)
xor    %ebx,%ebx
cmp    $0x2,%ecx
jl     128b <genericMemcachedCommand+0x15b>
mov    0x8(%rsp),%r15d
xor    %r12d,%r12d
xor    %ebx,%ebx
jmp    11c2 <genericMemcachedCommand+0x92>
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%r12,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,%rbp
movslq %ebx,%rbx
lea    (%rbx,%r13,1),%rdi
mov    (%r14,%r12,8),%rsi
mov    %rbp,%rdx
call   1040 <memcpy@plt>
mov    %ebx,%eax
add    %ebp,%eax
add    %ebp,%ebx
add    $0x1,%ebx
cltq
movb   $0x20,0x0(%r13,%rax,1)
add    $0x1,%r12
cmp    %r12,%r15
mov    0x10(%rsp),%r9
je     128b <genericMemcachedCommand+0x15b>
cmpl   $0x0,(%rsp)
je     1180 <genericMemcachedCommand+0x50>
test   %r9,%r9
je     11e0 <genericMemcachedCommand+0xb0>
mov    (%r9,%r12,8),%rbp
jmp    118c <genericMemcachedCommand+0x5c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14,%r12,8),%rdi
call   1030 <strlen@plt>
jmp    1189 <genericMemcachedCommand+0x59>
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     12d1 <genericMemcachedCommand+0x1a1>
lea    -0x1(%rcx),%eax
mov    %eax,0x4(%rsp)
xor    %r12d,%r12d
cmp    $0x2,%ecx
jl     12a1 <genericMemcachedCommand+0x171>
mov    0x4(%rsp),%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
xor    %r12d,%r12d
jmp    1266 <genericMemcachedCommand+0x136>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,%r15
movslq %r12d,%rbp
mov    %r13,%rdi
add    %rbp,%rdi
mov    (%r14,%rbx,8),%rsi
mov    %r15,%rdx
call   1040 <memcpy@plt>
mov    %ebp,%eax
add    %r15d,%eax
lea    (%r15,%rbp,1),%r12d
add    $0x1,%r12d
cltq
movb   $0x20,0x0(%r13,%rax,1)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
mov    0x10(%rsp),%r9
je     12a1 <genericMemcachedCommand+0x171>
cmpl   $0x0,(%rsp)
je     1220 <genericMemcachedCommand+0xf0>
test   %r9,%r9
je     1280 <genericMemcachedCommand+0x150>
mov    (%r9,%rbx,8),%r15
jmp    122c <genericMemcachedCommand+0xfc>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <strlen@plt>
jmp    1229 <genericMemcachedCommand+0xf9>
cmpl   $0x0,(%rsp)
je     12ca <genericMemcachedCommand+0x19a>
movslq 0x8(%rsp),%r12
test   %r9,%r9
je     12bf <genericMemcachedCommand+0x18f>
mov    (%r9,%r12,8),%rbp
jmp    12e9 <genericMemcachedCommand+0x1b9>
movslq %r12d,%rbx
movw   $0xa0d,0x0(%r13,%rbx,1)
0a
add    $0x2,%ebx
cmpl   $0x0,(%rsp)
je     12d8 <genericMemcachedCommand+0x1a8>
movslq 0x4(%rsp),%r12
test   %r9,%r9
jne    129b <genericMemcachedCommand+0x16b>
mov    (%r14,%r12,8),%rdi
call   1030 <strlen@plt>
jmp    12e6 <genericMemcachedCommand+0x1b6>
movslq 0x8(%rsp),%r12
jmp    12dd <genericMemcachedCommand+0x1ad>
mov    $0xffffffff,%eax
jmp    130f <genericMemcachedCommand+0x1df>
movslq 0x4(%rsp),%r12
mov    (%r14,%r12,8),%rdi
call   1050 <sdslen@plt>
mov    %rax,%rbp
movslq %ebx,%rbx
lea    (%rbx,%r13,1),%rdi
mov    (%r14,%r12,8),%rsi
mov    %rbp,%rdx
call   1040 <memcpy@plt>
lea    (%rbx,%rbp,1),%eax
cltq
movw   $0xa0d,0x0(%r13,%rax,1)
0a
lea    (%rbx,%rbp,1),%eax
add    $0x2,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @genericMemcachedCommand(i32 %0, i8* %1, i32 %2, i32 %3, i8** %4, i64* %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8**
%12 = alloca i64*
%13 = alloca i32
%14 = alloca i64
%15 = alloca i32
store i32 %0, i32* %7
store i8* %1, i8** %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i8** %4, i8*** %11
store i64* %5, i64** %12
store i32 0, i32* %15
%16 = load i32, i32* %7
switch i32 %16, label %264 [
i32 1, label %17
i32 2, label %17
i32 4, label %145
i32 3, label %145
i32 5, label %145
]
17: ; preds = %6, %6
store i32 0, i32* %13
br label %18
18: ; preds = %73, %17
%19 = load i32, i32* %13
%20 = load i32, i32* %10
%21 = sub nsw i32 %20, 1
%22 = icmp slt i32 %19, %21
br i1 %22, label %23, label %76
23: ; preds = %18
%24 = load i32, i32* %9
%25 = icmp eq i32 %24, 0
br i1 %25, label %26, label %33
26: ; preds = %23
%27 = load i8**, i8*** %11
%28 = load i32, i32* %13
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8*, i8** %27, i64 %29
%31 = load i8*, i8** %30
%32 = call i64 @sdslen(i8* %31)
br label %51
33: ; preds = %23
%34 = load i64*, i64** %12
%35 = icmp eq i64* %34, null
br i1 %35, label %36, label %43
36: ; preds = %33
%37 = load i8**, i8*** %11
%38 = load i32, i32* %13
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8*, i8** %37, i64 %39
%41 = load i8*, i8** %40
%42 = call i64 @strlen(i8* %41)
br label %49
43: ; preds = %33
%44 = load i64*, i64** %12
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i64, i64* %44, i64 %46
%48 = load i64, i64* %47
br label %49
49: ; preds = %43, %36
%50 = phi i64 [ %42, %36 ], [ %48, %43 ]
br label %51
51: ; preds = %49, %26
%52 = phi i64 [ %32, %26 ], [ %50, %49 ]
store i64 %52, i64* %14
%53 = load i8*, i8** %8
%54 = load i32, i32* %15
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
%57 = load i8**, i8*** %11
%58 = load i32, i32* %13
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8*, i8** %57, i64 %59
%61 = load i8*, i8** %60
%62 = load i64, i64* %14
%63 = call i32 @memcpy(i8* %56, i8* %61, i64 %62)
%64 = load i64, i64* %14
%65 = trunc i64 %64 to i32
%66 = load i32, i32* %15
%67 = add nsw i32 %66, %65
store i32 %67, i32* %15
%68 = load i8*, i8** %8
%69 = load i32, i32* %15
%70 = add nsw i32 %69, 1
store i32 %70, i32* %15
%71 = sext i32 %69 to i64
%72 = getelementptr inbounds i8, i8* %68, i64 %71
store i8 32, i8* %72
br label %73
73: ; preds = %51
%74 = load i32, i32* %13
%75 = add nsw i32 %74, 1
store i32 %75, i32* %13
br label %18
76: ; preds = %18
%77 = load i8*, i8** %8
%78 = load i32, i32* %15
%79 = add nsw i32 %78, 1
store i32 %79, i32* %15
%80 = sext i32 %78 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
store i8 13, i8* %81
%82 = load i8*, i8** %8
%83 = load i32, i32* %15
%84 = add nsw i32 %83, 1
store i32 %84, i32* %15
%85 = sext i32 %83 to i64
%86 = getelementptr inbounds i8, i8* %82, i64 %85
store i8 10, i8* %86
%87 = load i32, i32* %9
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %97
89: ; preds = %76
%90 = load i8**, i8*** %11
%91 = load i32, i32* %10
%92 = sub nsw i32 %91, 1
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8*, i8** %90, i64 %93
%95 = load i8*, i8** %94
%96 = call i64 @sdslen(i8* %95)
br label %117
97: ; preds = %76
%98 = load i64*, i64** %12
%99 = icmp eq i64* %98, null
br i1 %99, label %100, label %108
100: ; preds = %97
%101 = load i8**, i8*** %11
%102 = load i32, i32* %10
%103 = sub nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8*, i8** %101, i64 %104
%106 = load i8*, i8** %105
%107 = call i64 @strlen(i8* %106)
br label %115
108: ; preds = %97
%109 = load i64*, i64** %12
%110 = load i32, i32* %10
%111 = sub nsw i32 %110, 1
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i64, i64* %109, i64 %112
%114 = load i64, i64* %113
br label %115
115: ; preds = %108, %100
%116 = phi i64 [ %107, %100 ], [ %114, %108 ]
br label %117
117: ; preds = %115, %89
%118 = phi i64 [ %96, %89 ], [ %116, %115 ]
store i64 %118, i64* %14
%119 = load i8*, i8** %8
%120 = load i32, i32* %15
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8**, i8*** %11
%124 = load i32, i32* %10
%125 = sub nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8*, i8** %123, i64 %126
%128 = load i8*, i8** %127
%129 = load i64, i64* %14
%130 = call i32 @memcpy(i8* %122, i8* %128, i64 %129)
%131 = load i64, i64* %14
%132 = trunc i64 %131 to i32
%133 = load i32, i32* %15
%134 = add nsw i32 %133, %132
store i32 %134, i32* %15
%135 = load i8*, i8** %8
%136 = load i32, i32* %15
%137 = add nsw i32 %136, 1
store i32 %137, i32* %15
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds i8, i8* %135, i64 %138
store i8 13, i8* %139
%140 = load i8*, i8** %8
%141 = load i32, i32* %15
%142 = add nsw i32 %141, 1
store i32 %142, i32* %15
%143 = sext i32 %141 to i64
%144 = getelementptr inbounds i8, i8* %140, i64 %143
store i8 10, i8* %144
br label %265
145: ; preds = %6, %6, %6
store i32 0, i32* %13
br label %146
146: ; preds = %202, %145
%147 = load i32, i32* %13
%148 = load i32, i32* %10
%149 = sub nsw i32 %148, 1
%150 = icmp slt i32 %147, %149
br i1 %150, label %151, label %205
151: ; preds = %146
%152 = load i32, i32* %9
%153 = icmp eq i32 %152, 0
br i1 %153, label %154, label %161
154: ; preds = %151
%155 = load i8**, i8*** %11
%156 = load i32, i32* %13
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8*, i8** %155, i64 %157
%159 = load i8*, i8** %158
%160 = call i64 @sdslen(i8* %159)
br label %179
161: ; preds = %151
%162 = load i64*, i64** %12
%163 = icmp eq i64* %162, null
br i1 %163, label %164, label %171
164: ; preds = %161
%165 = load i8**, i8*** %11
%166 = load i32, i32* %13
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i8*, i8** %165, i64 %167
%169 = load i8*, i8** %168
%170 = call i64 @strlen(i8* %169)
br label %177
171: ; preds = %161
%172 = load i64*, i64** %12
%173 = load i32, i32* %13
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i64, i64* %172, i64 %174
%176 = load i64, i64* %175
br label %177
177: ; preds = %171, %164
%178 = phi i64 [ %170, %164 ], [ %176, %171 ]
br label %179
179: ; preds = %177, %154
%180 = phi i64 [ %160, %154 ], [ %178, %177 ]
store i64 %180, i64* %14
%181 = load i8*, i8** %8
%182 = load i32, i32* %15
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %181, i64 %183
%185 = load i8**, i8*** %11
%186 = load i32, i32* %13
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8*, i8** %185, i64 %187
%189 = load i8*, i8** %188
%190 = load i64, i64* %14
%191 = call i32 @memcpy(i8* %184, i8* %189, i64 %190)
%192 = load i64, i64* %14
%193 = load i32, i32* %15
%194 = sext i32 %193 to i64
%195 = add i64 %194, %192
%196 = trunc i64 %195 to i32
store i32 %196, i32* %15
%197 = load i8*, i8** %8
%198 = load i32, i32* %15
%199 = add nsw i32 %198, 1
store i32 %199, i32* %15
%200 = sext i32 %198 to i64
%201 = getelementptr inbounds i8, i8* %197, i64 %200
store i8 32, i8* %201
br label %202
202: ; preds = %179
%203 = load i32, i32* %13
%204 = add nsw i32 %203, 1
store i32 %204, i32* %13
br label %146
205: ; preds = %146
%206 = load i32, i32* %9
%207 = icmp eq i32 %206, 0
br i1 %207, label %208, label %216
208: ; preds = %205
%209 = load i8**, i8*** %11
%210 = load i32, i32* %10
%211 = sub nsw i32 %210, 1
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8*, i8** %209, i64 %212
%214 = load i8*, i8** %213
%215 = call i64 @sdslen(i8* %214)
br label %236
216: ; preds = %205
%217 = load i64*, i64** %12
%218 = icmp eq i64* %217, null
br i1 %218, label %219, label %227
219: ; preds = %216
%220 = load i8**, i8*** %11
%221 = load i32, i32* %10
%222 = sub nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8*, i8** %220, i64 %223
%225 = load i8*, i8** %224
%226 = call i64 @strlen(i8* %225)
br label %234
227: ; preds = %216
%228 = load i64*, i64** %12
%229 = load i32, i32* %10
%230 = sub nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i64, i64* %228, i64 %231
%233 = load i64, i64* %232
br label %234
234: ; preds = %227, %219
%235 = phi i64 [ %226, %219 ], [ %233, %227 ]
br label %236
236: ; preds = %234, %208
%237 = phi i64 [ %215, %208 ], [ %235, %234 ]
store i64 %237, i64* %14
%238 = load i8*, i8** %8
%239 = load i32, i32* %15
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %238, i64 %240
%242 = load i8**, i8*** %11
%243 = load i32, i32* %10
%244 = sub nsw i32 %243, 1
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i8*, i8** %242, i64 %245
%247 = load i8*, i8** %246
%248 = load i64, i64* %14
%249 = call i32 @memcpy(i8* %241, i8* %247, i64 %248)
%250 = load i64, i64* %14
%251 = trunc i64 %250 to i32
%252 = load i32, i32* %15
%253 = add nsw i32 %252, %251
store i32 %253, i32* %15
%254 = load i8*, i8** %8
%255 = load i32, i32* %15
%256 = add nsw i32 %255, 1
store i32 %256, i32* %15
%257 = sext i32 %255 to i64
%258 = getelementptr inbounds i8, i8* %254, i64 %257
store i8 13, i8* %258
%259 = load i8*, i8** %8
%260 = load i32, i32* %15
%261 = add nsw i32 %260, 1
store i32 %261, i32* %15
%262 = sext i32 %260 to i64
%263 = getelementptr inbounds i8, i8* %259, i64 %262
store i8 10, i8* %263
br label %265
264: ; preds = %6
store i32 -1, i32* %15
br label %265
265: ; preds = %264, %236, %117
%266 = load i32, i32* %15
ret i32 %266
}

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