unsigned short GetTLV(void *pQMIMessage, unsigned short messageLen,
                      unsigned char type, void *pOutDataBuf,
                      unsigned short bufferLen) {
  unsigned short pos;
  unsigned short tlvSize = 0;
  unsigned short cpyCount;
  if (pQMIMessage == 0 || pOutDataBuf == 0) {
    return -12;
  }
  for (pos = 4; pos + 3 < messageLen; pos += tlvSize + 3) {
    tlvSize = *(unsigned short *)(pQMIMessage + pos + 1);
    if (*(unsigned char *)(pQMIMessage + pos) == type) {
      if (bufferLen < tlvSize) {
        return -12;
      }
      for (cpyCount = 0; cpyCount < tlvSize; cpyCount++) {
        *((char *)(pOutDataBuf + cpyCount)) =
            *((char *)(pQMIMessage + pos + 3 + cpyCount));
      }
      return tlvSize;
    }
  }
  return -42;
}


x86 assembly (clang, -O0):
<GetTLV>:
push   %rbp
mov    %rsp,%rbp
mov    %r8w,%ax
mov    %rdi,-0x10(%rbp)
mov    %si,-0x12(%rbp)
mov    %dl,-0x13(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %ax,-0x22(%rbp)
movw   $0x0,-0x26(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1137 <GetTLV+0x37>
cmpq   $0x0,-0x20(%rbp)
jne    1142 <GetTLV+0x42>
movw   $0xfff4,-0x2(%rbp)
jmp    1221 <GetTLV+0x121>
movw   $0x4,-0x24(%rbp)
movzwl -0x24(%rbp),%eax
add    $0x3,%eax
movzwl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jge    121b <GetTLV+0x11b>
mov    -0x10(%rbp),%rax
movzwl -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    0x1(%rax,%rcx,1),%ax
mov    %ax,-0x26(%rbp)
mov    -0x10(%rbp),%rax
movzwl -0x24(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x13(%rbp),%ecx
cmp    %ecx,%eax
jne    1200 <GetTLV+0x100>
movzwl -0x22(%rbp),%eax
movzwl -0x26(%rbp),%ecx
cmp    %ecx,%eax
jge    11a5 <GetTLV+0xa5>
movw   $0xfff4,-0x2(%rbp)
jmp    1221 <GetTLV+0x121>
movw   $0x0,-0x28(%rbp)
movzwl -0x28(%rbp),%eax
movzwl -0x26(%rbp),%ecx
cmp    %ecx,%eax
jge    11f3 <GetTLV+0xf3>
mov    -0x10(%rbp),%rax
movzwl -0x24(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
movzwl -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    0x3(%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movzwl -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x28(%rbp)
jmp    11ab <GetTLV+0xab>
mov    -0x26(%rbp),%ax
mov    %ax,-0x2(%rbp)
jmp    1221 <GetTLV+0x121>
jmp    1205 <GetTLV+0x105>
movzwl -0x26(%rbp),%ecx
add    $0x3,%ecx
movzwl -0x24(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x24(%rbp)
jmp    1148 <GetTLV+0x48>
movw   $0xffd6,-0x2(%rbp)
movzwl -0x2(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<GetTLV>:
push   %r14
push   %rbx
mov    $0xfff4,%ax
test   %rdi,%rdi
je     1147 <GetTLV+0x47>
test   %rcx,%rcx
je     1147 <GetTLV+0x47>
cmp    $0x8,%si
jb     1143 <GetTLV+0x43>
movzwl %si,%r11d
mov    $0x4,%ebx
mov    %ebx,%esi
movzwl 0x1(%rdi,%rsi,1),%r9d
movzwl %r9w,%r10d
cmp    %dl,(%rdi,%rsi,1)
je     114b <GetTLV+0x4b>
lea    (%rbx,%r10,1),%esi
add    $0x3,%esi
movzwl %si,%ebx
lea    0x3(%rbx),%esi
cmp    %r11d,%esi
jb     1120 <GetTLV+0x20>
mov    $0xffd6,%ax
pop    %rbx
pop    %r14
ret
cmp    %r8w,%r9w
ja     1147 <GetTLV+0x47>
test   %r9w,%r9w
je     11f3 <GetTLV+0xf3>
lea    (%rdi,%rsi,1),%rax
lea    0x3(%rax),%r11
cmp    $0x8,%r9w
jb     1183 <GetTLV+0x83>
add    %r10,%rax
add    $0x3,%rax
cmp    %rcx,%rax
jbe    11fa <GetTLV+0xfa>
lea    (%rcx,%r10,1),%rax
cmp    %rax,%r11
jae    11fa <GetTLV+0xfa>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
add    %r10,%r8
mov    %r10,%rbx
and    $0x3,%rbx
je     11b2 <GetTLV+0xb2>
nopw   0x0(%rax,%rax,1)
movzbl (%r11,%rax,1),%edx
mov    %dl,(%rcx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    11a0 <GetTLV+0xa0>
cmp    $0x3,%r8
jb     11eb <GetTLV+0xeb>
lea    (%rdi,%rsi,1),%rdx
add    $0x6,%rdx
movzbl -0x3(%rdx,%rax,1),%ebx
mov    %bl,(%rcx,%rax,1)
movzbl -0x2(%rdx,%rax,1),%ebx
mov    %bl,0x1(%rcx,%rax,1)
movzbl -0x1(%rdx,%rax,1),%ebx
mov    %bl,0x2(%rcx,%rax,1)
movzbl (%rdx,%rax,1),%ebx
mov    %bl,0x3(%rcx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r10
jne    11c0 <GetTLV+0xc0>
mov    %r9d,%eax
jmp    1147 <GetTLV+0x47>
xor    %eax,%eax
jmp    1147 <GetTLV+0x47>
cmp    $0x20,%r9w
jae    1208 <GetTLV+0x108>
xor    %eax,%eax
jmp    12e1 <GetTLV+0x1e1>
mov    %r10d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rdx
mov    %rdx,%r14
shr    $0x5,%r14
add    $0x1,%r14
mov    %r14d,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    122e <GetTLV+0x12e>
xor    %ebx,%ebx
jmp    1294 <GetTLV+0x194>
and    $0xfffffffffffffffc,%r14
lea    (%rdi,%rsi,1),%rdx
add    $0x73,%rdx
xor    %ebx,%ebx
movups -0x70(%rdx,%rbx,1),%xmm0
movups -0x60(%rdx,%rbx,1),%xmm1
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
movups -0x50(%rdx,%rbx,1),%xmm0
movups -0x40(%rdx,%rbx,1),%xmm1
movups %xmm0,0x20(%rcx,%rbx,1)
movups %xmm1,0x30(%rcx,%rbx,1)
movups -0x30(%rdx,%rbx,1),%xmm0
movups -0x20(%rdx,%rbx,1),%xmm1
movups %xmm0,0x40(%rcx,%rbx,1)
movups %xmm1,0x50(%rcx,%rbx,1)
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,0x60(%rcx,%rbx,1)
movups %xmm1,0x70(%rcx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%r14
jne    123c <GetTLV+0x13c>
test   %r8,%r8
je     12ce <GetTLV+0x1ce>
lea    (%rbx,%rcx,1),%r14
add    $0x10,%r14
add    %rdi,%rbx
add    %rsi,%rbx
add    $0x13,%rbx
shl    $0x5,%r8
xor    %edx,%edx
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%r14,%rdx,1)
movups %xmm1,(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    12b1 <GetTLV+0x1b1>
cmp    %r10,%rax
je     11eb <GetTLV+0xeb>
test   $0x18,%r10b
je     1185 <GetTLV+0x85>
mov    %rax,%rdx
mov    %r10d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r11,%rdx,1),%rbx
mov    %rbx,(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    12f0 <GetTLV+0x1f0>
cmp    %r10,%rax
jne    1185 <GetTLV+0x85>
jmp    11eb <GetTLV+0xeb>

LLVM IR (-O0):
define zeroext i16 @GetTLV(i8* %0, i16 zeroext %1, i8 zeroext %2, i8* %3, i16 zeroext %4) {
%6 = alloca i16
%7 = alloca i8*
%8 = alloca i16
%9 = alloca i8
%10 = alloca i8*
%11 = alloca i16
%12 = alloca i16
%13 = alloca i16
%14 = alloca i16
store i8* %0, i8** %7
store i16 %1, i16* %8
store i8 %2, i8* %9
store i8* %3, i8** %10
store i16 %4, i16* %11
store i16 0, i16* %13
%15 = load i8*, i8** %7
%16 = icmp eq i8* %15, null
br i1 %16, label %20, label %17
17: ; preds = %5
%18 = load i8*, i8** %10
%19 = icmp eq i8* %18, null
br i1 %19, label %20, label %21
20: ; preds = %17, %5
store i16 -12, i16* %6
br label %94
21: ; preds = %17
store i16 4, i16* %12
br label %22
22: ; preds = %85, %21
%23 = load i16, i16* %12
%24 = zext i16 %23 to i32
%25 = add nsw i32 %24, 3
%26 = load i16, i16* %8
%27 = zext i16 %26 to i32
%28 = icmp slt i32 %25, %27
br i1 %28, label %29, label %93
29: ; preds = %22
%30 = load i8*, i8** %7
%31 = load i16, i16* %12
%32 = zext i16 %31 to i32
%33 = sext i32 %32 to i64
%34 = getelementptr i8, i8* %30, i64 %33
%35 = getelementptr i8, i8* %34, i64 1
%36 = bitcast i8* %35 to i16*
%37 = load i16, i16* %36
store i16 %37, i16* %13
%38 = load i8*, i8** %7
%39 = load i16, i16* %12
%40 = zext i16 %39 to i32
%41 = sext i32 %40 to i64
%42 = getelementptr i8, i8* %38, i64 %41
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = load i8, i8* %9
%46 = zext i8 %45 to i32
%47 = icmp eq i32 %44, %46
br i1 %47, label %48, label %84
48: ; preds = %29
%49 = load i16, i16* %11
%50 = zext i16 %49 to i32
%51 = load i16, i16* %13
%52 = zext i16 %51 to i32
%53 = icmp slt i32 %50, %52
br i1 %53, label %54, label %55
54: ; preds = %48
store i16 -12, i16* %6
br label %94
55: ; preds = %48
store i16 0, i16* %14
br label %56
56: ; preds = %79, %55
%57 = load i16, i16* %14
%58 = zext i16 %57 to i32
%59 = load i16, i16* %13
%60 = zext i16 %59 to i32
%61 = icmp slt i32 %58, %60
br i1 %61, label %62, label %82
62: ; preds = %56
%63 = load i8*, i8** %7
%64 = load i16, i16* %12
%65 = zext i16 %64 to i32
%66 = sext i32 %65 to i64
%67 = getelementptr i8, i8* %63, i64 %66
%68 = getelementptr i8, i8* %67, i64 3
%69 = load i16, i16* %14
%70 = zext i16 %69 to i32
%71 = sext i32 %70 to i64
%72 = getelementptr i8, i8* %68, i64 %71
%73 = load i8, i8* %72
%74 = load i8*, i8** %10
%75 = load i16, i16* %14
%76 = zext i16 %75 to i32
%77 = sext i32 %76 to i64
%78 = getelementptr i8, i8* %74, i64 %77
store i8 %73, i8* %78
br label %79
79: ; preds = %62
%80 = load i16, i16* %14
%81 = add i16 %80, 1
store i16 %81, i16* %14
br label %56
82: ; preds = %56
%83 = load i16, i16* %13
store i16 %83, i16* %6
br label %94
84: ; preds = %29
br label %85
85: ; preds = %84
%86 = load i16, i16* %13
%87 = zext i16 %86 to i32
%88 = add nsw i32 %87, 3
%89 = load i16, i16* %12
%90 = zext i16 %89 to i32
%91 = add nsw i32 %90, %88
%92 = trunc i32 %91 to i16
store i16 %92, i16* %12
br label %22
93: ; preds = %22
store i16 -42, i16* %6
br label %94
94: ; preds = %93, %82, %54, %20
%95 = load i16, i16* %6
ret i16 %95
}

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