int iParseToTrace(int iTraceType, int iInfoType, unsigned char *psInfo,
                  int iInfoLen, int iIndent, int iRecursionLevel) {
  unsigned char szMsg[1024], *pszMsg;
  int iTabLen = 4;
  int iRet;
  int iValueLen;
  unsigned char *psTlvObjValue, *psTlvObj;
  int iIndex, iTlvObjLen;
  unsigned char *p;
  int i;
  szMsg[0] = 0;
  switch (iInfoType) {
  case 4:
    while (iInfoLen > 0) {
      int iTagLen;
      iTagLen = iTlvTagLen(psInfo);
      if (iTagLen <= 0) {
        vTraceWriteTxtCr(iTraceType, "%*sFormat error", iIndent, "");
        return (1);
      }
      if (iInfoLen < iTagLen + 1) {
        vTraceWriteTxtCr(iTraceType, "%*sFormat error", iIndent, "");
        return (1);
      }
      pszMsg = szMsg;
      sprintf(pszMsg, "%*s", iIndent, "");
      pszMsg += strlen(pszMsg);
      vOneTwo0(psInfo, iTagLen, pszMsg);
      pszMsg += strlen(pszMsg);
      *pszMsg++ = ' ';
      vOneTwo0(psInfo + iTagLen, 1, pszMsg);
      pszMsg += 2;
      sprintf(pszMsg, " // %s", psTagAttrGetDesc(psInfo));
      vTraceWriteTxtCr(iTraceType, szMsg);
      psInfo += iTagLen + 1;
      iInfoLen -= iTagLen + 1;
    }
    break;
  case 2:
    iRet = iTlvCheckTlvObject(psInfo);
    if (iRet < 0 || iRet > iInfoLen) {
      vTraceWriteTxtCr(iTraceType, "%*sFormat error", iIndent, "");
      return (1);
    }
    iValueLen = iTlvValue(psInfo, &psTlvObjValue);
    if (iRet < 2) {
      vTraceWriteTxtCr(iTraceType, "%*sFormat error, less data length", iIndent,
                       "");
      return (1);
    }
    pszMsg = szMsg;
    sprintf(pszMsg, "%*s", iIndent, "");
    pszMsg += strlen(pszMsg);
    vOneTwo0(psTlvObjValue, 2, pszMsg);
    pszMsg += strlen(pszMsg);
    strcpy(pszMsg, " // [Support:");
    pszMsg += strlen(pszMsg);
    if (psTlvObjValue[0] & 0x40)
      strcpy(pszMsg, " SDA");
    if (psTlvObjValue[0] & 0x20)
      strcpy(pszMsg, " DDA");
    if (psTlvObjValue[0] & 0x10)
      strcpy(pszMsg, " Card holder verification");
    if (psTlvObjValue[0] & 0x08)
      strcpy(pszMsg, " Terminal risk management");
    if (psTlvObjValue[0] & 0x04)
      strcpy(pszMsg, " Issuer auth");
    if (psTlvObjValue[0] & 0x01)
      strcpy(pszMsg, " CDA");
    if (psTlvObjValue[1] & 0x80)
      strcpy(pszMsg, " MSD");
    pszMsg += strlen(pszMsg);
    strcpy(pszMsg, "] AIP");
    vTraceWriteTxtCr(iTraceType, szMsg);
    pszMsg = szMsg;
    for (i = 0; i < (iValueLen - 2) / 4; i++) {
      p = psTlvObjValue + 2 + i * 4;
      sprintf(pszMsg, "%*s", iIndent, "");
      pszMsg += strlen(pszMsg);
      vOneTwo0(p, 4, pszMsg);
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, " // [");
      pszMsg += strlen(pszMsg);
      sprintf(pszMsg, "SFI:%d", p[0] >> 3);
      pszMsg += strlen(pszMsg);
      sprintf(pszMsg, " First Record No.:%d", p[1]);
      pszMsg += strlen(pszMsg);
      sprintf(pszMsg, " Last Record No.:%d", p[2]);
      pszMsg += strlen(pszMsg);
      if (p[3]) {
        sprintf(pszMsg, " Need to be signed:%d", p[3]);
        pszMsg += strlen(pszMsg);
      }
      sprintf(pszMsg, "] // AFL Entry %d", i);
      vTraceWriteTxtCr(iTraceType, szMsg);
    }
    break;
  case 3:
    iRet = iTlvCheckTlvObject(psInfo);
    if (iRet < 0 || iRet > iInfoLen) {
      vTraceWriteTxtCr(iTraceType, "%*sFormat error", iIndent, "");
      return (1);
    }
    iValueLen = iTlvValue(psInfo, &psTlvObjValue);
    if (iRet < 11) {
      vTraceWriteTxtCr(iTraceType, "%*sFormat error, less data length", iIndent,
                       "");
      return (1);
    }
    pszMsg = szMsg;
    sprintf(pszMsg, "%*s", iIndent, "");
    pszMsg += strlen(pszMsg);
    vOneTwo0(psTlvObjValue, 1, pszMsg);
    pszMsg += strlen(pszMsg);
    strcpy(pszMsg, " // CID");
    vTraceWriteTxtCr(iTraceType, "%s", szMsg);
    pszMsg = szMsg;
    sprintf(pszMsg, "%*s", iIndent, "");
    pszMsg += strlen(pszMsg);
    vOneTwo0(psTlvObjValue + 1, 2, pszMsg);
    pszMsg += strlen(pszMsg);
    strcpy(pszMsg, " // ATC");
    vTraceWriteTxtCr(iTraceType, "%s", szMsg);
    pszMsg = szMsg;
    sprintf(pszMsg, "%*s", iIndent, "");
    pszMsg += strlen(pszMsg);
    vOneTwo0(psTlvObjValue + 3, 8, pszMsg);
    pszMsg += strlen(pszMsg);
    strcpy(pszMsg, " // AC");
    vTraceWriteTxtCr(iTraceType, "%s", szMsg);
    if (iValueLen - 11 > 0) {
      pszMsg = szMsg;
      sprintf(pszMsg, "%*s", iIndent, "");
      pszMsg += strlen(pszMsg);
      vOneTwo0(psTlvObjValue + 11, iValueLen - 11, pszMsg);
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, " // IAD(T9F10)");
      vTraceWriteTxtCr(iTraceType, "%s", szMsg);
    }
    break;
  case 5:
    iRet = iTlvGetObjByIndex(psInfo, 0, &psTlvObj);
    if (iRet <= 0) {
      vTraceWriteTxtCr(iTraceType, "%*sTlv DB is empy", iIndent, "");
      return (1);
    }
    for (i = 0;; i++) {
      iRet = iTlvGetObjByIndex(psInfo, i, &psTlvObj);
      if (iRet <= 0)
        break;
      iRet = iParseToTrace(iTraceType, 1, psInfo, iInfoLen, iIndent, 0);
      if (iRet)
        return (1);
    }
    break;
  case 1:
    iRet = iTlvCheckTlvObject(psInfo);
    if (iRet < 0 || iRet > iInfoLen) {
      vTraceWriteTxtCr(iTraceType, "%*sFormat error", iIndent, "");
      return (1);
    }
    if ((psInfo[0] & 0x20) == 0) {
      pszMsg = szMsg;
      sprintf(pszMsg, "%*s", iIndent, "");
      pszMsg += strlen(pszMsg);
      vOneTwo0(psInfo, iTlvTagLen(psInfo), pszMsg);
      pszMsg += strlen(pszMsg);
      *pszMsg++ = ' ';
      vOneTwo0(psInfo + iTlvTagLen(psInfo), iTlvLengthLen(psInfo), pszMsg);
      pszMsg += strlen(pszMsg);
      *pszMsg++ = ' ';
      vOneTwo0(psTlvValue(psInfo), iTlvValueLen(psInfo), pszMsg);
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, " // ");
      pszMsg += strlen(pszMsg);
      vAddExtraInfo(pszMsg, psInfo);
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, psTagAttrGetDesc(psInfo));
      vTraceWriteTxtCr(iTraceType, "%s", szMsg);
      return (0);
    } else {
      pszMsg = szMsg;
      sprintf(pszMsg, "%*s", iIndent, "");
      pszMsg += strlen(pszMsg);
      vOneTwo0(psInfo, iTlvTagLen(psInfo), pszMsg);
      pszMsg += strlen(pszMsg);
      *pszMsg++ = ' ';
      vOneTwo0(psInfo + iTlvTagLen(psInfo), iTlvLengthLen(psInfo), pszMsg);
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, " // ");
      pszMsg += strlen(pszMsg);
      strcpy(pszMsg, psTagAttrGetDesc(psInfo));
      vTraceWriteTxtCr(iTraceType, "%s", szMsg);
      for (iIndex = 0;; iIndex++) {
        iTlvObjLen = iTlvSerachTemplate(psInfo, iInfoLen, iIndex, &psTlvObj);
        if (iTlvObjLen == -10004)
          break;
        if (iTlvObjLen <= 0) {
          vTraceWriteTxtCr(iTraceType, "%*sParse error", iIndent + iTabLen, "");
          return (1);
        }
        iRet = iParseToTrace(iTraceType, 1, psTlvObj, iTlvObjLen,
                             iIndent + iTabLen, iRecursionLevel + 1);
        if (iRet)
          return (1);
      }
    }
    break;
  case 6:
    pszMsg = szMsg;
    while (iInfoLen > 0) {
      iTlvObjLen = iTlvCheckTlvObject(psInfo);
      if (iTlvObjLen < 0 || iTlvObjLen > iInfoLen)
        return (1);
      memset(pszMsg, '-', iIndent);
      pszMsg += iIndent;
      vOneTwo0(psInfo, iTlvObjLen, pszMsg);
      pszMsg += iTlvObjLen * 2;
      strcpy(pszMsg, "\x0d\x0a");
      pszMsg += strlen(pszMsg);
      iInfoLen -= iTlvObjLen;
      psInfo += iTlvObjLen;
    }
    vTraceWriteTxt(iTraceType, szMsg);
    break;
  default:
    vTraceWriteTxtCr(iTraceType, "%*sUnknown info type", iIndent, "");
    return (1);
  }
  return (0);
}


x86 assembly (clang, -O0):
<iParseToTrace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d0,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x4,-0x43c(%rbp)
movb   $0x0,-0x430(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x478(%rbp)
sub    $0x5,%eax
ja     236b <iParseToTrace+0x114b>
mov    -0x478(%rbp),%rax
lea    0x1d89(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1285 <iParseToTrace+0x65>
cmpl   $0x0,-0x1c(%rbp)
jle    1441 <iParseToTrace+0x221>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10d0 <iTlvTagLen@plt>
mov    %eax,-0x470(%rbp)
cmpl   $0x0,-0x470(%rbp)
jg     12d4 <iParseToTrace+0xb4>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1d5e(%rip),%rsi
lea    0x1ea9(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x1c(%rbp),%eax
mov    -0x470(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    130f <iParseToTrace+0xef>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1d23(%rip),%rsi
lea    0x1e6e(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x1cfa(%rip),%rsi
lea    0x1e35(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x470(%rbp),%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x438(%rbp)
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rdi
movslq -0x470(%rbp),%rax
add    %rax,%rdi
mov    -0x438(%rbp),%rdx
mov    $0x1,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10e0 <psTagAttrGetDesc@plt>
mov    -0x480(%rbp),%rdi
mov    %eax,%edx
lea    0x1c30(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
mov    -0x470(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x470(%rbp),%ecx
add    $0x1,%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1285 <iParseToTrace+0x65>
jmp    2392 <iParseToTrace+0x1172>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10b0 <iTlvCheckTlvObject@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
jl     1473 <iParseToTrace+0x253>
mov    -0x440(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    149a <iParseToTrace+0x27a>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1b98(%rip),%rsi
lea    0x1ce3(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x18(%rbp),%rdi
lea    -0x450(%rbp),%rsi
mov    $0x0,%al
call   1040 <iTlvValue@plt>
mov    %eax,-0x444(%rbp)
cmpl   $0x2,-0x440(%rbp)
jge    14e6 <iParseToTrace+0x2c6>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1b67(%rip),%rsi
lea    0x1c97(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x1b23(%rip),%rsi
lea    0x1c5e(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rdi
mov    -0x438(%rbp),%rdx
mov    $0x2,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x1ae6(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     15b7 <iParseToTrace+0x397>
mov    -0x438(%rbp),%rdi
lea    0x1ab1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     15e0 <iParseToTrace+0x3c0>
mov    -0x438(%rbp),%rdi
lea    0x1a8d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1609 <iParseToTrace+0x3e9>
mov    -0x438(%rbp),%rdi
lea    0x1a69(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1632 <iParseToTrace+0x412>
mov    -0x438(%rbp),%rdi
lea    0x1a5a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     165b <iParseToTrace+0x43b>
mov    -0x438(%rbp),%rdi
lea    0x1a4b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl (%rax),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1684 <iParseToTrace+0x464>
mov    -0x438(%rbp),%rdi
lea    0x1a2f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x450(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     16b0 <iParseToTrace+0x490>
mov    -0x438(%rbp),%rdi
lea    0x1a08(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x19e0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
movl   $0x0,-0x46c(%rbp)
mov    -0x46c(%rbp),%eax
mov    %eax,-0x484(%rbp)
mov    -0x444(%rbp),%eax
sub    $0x2,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x484(%rbp),%eax
cmp    %ecx,%eax
jge    1929 <iParseToTrace+0x709>
mov    -0x450(%rbp),%rax
add    $0x2,%rax
mov    -0x46c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x468(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x18c3(%rip),%rsi
lea    0x19fe(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x468(%rbp),%rdi
mov    -0x438(%rbp),%rdx
mov    $0x4,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x18ef(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x468(%rbp),%rax
movzbl (%rax),%edx
sar    $0x3,%edx
lea    0x18bb(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x468(%rbp),%rax
movzbl 0x1(%rax),%edx
lea    0x1888(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x468(%rbp),%rax
movzbl 0x2(%rax),%edx
lea    0x1863(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x468(%rbp),%rax
cmpb   $0x0,0x3(%rax)
je     18e9 <iParseToTrace+0x6c9>
mov    -0x438(%rbp),%rdi
mov    -0x468(%rbp),%rax
movzbl 0x3(%rax),%edx
lea    0x182c(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x46c(%rbp),%edx
lea    0x180d(%rip),%rsi
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
mov    -0x46c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x46c(%rbp)
jmp    1706 <iParseToTrace+0x4e6>
jmp    2392 <iParseToTrace+0x1172>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10b0 <iTlvCheckTlvObject@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
jl     195b <iParseToTrace+0x73b>
mov    -0x440(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1982 <iParseToTrace+0x762>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x16b0(%rip),%rsi
lea    0x17fb(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x18(%rbp),%rdi
lea    -0x450(%rbp),%rsi
mov    $0x0,%al
call   1040 <iTlvValue@plt>
mov    %eax,-0x444(%rbp)
cmpl   $0xb,-0x440(%rbp)
jge    19ce <iParseToTrace+0x7ae>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x167f(%rip),%rsi
lea    0x17af(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x163b(%rip),%rsi
lea    0x1776(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rdi
mov    -0x438(%rbp),%rdx
mov    $0x1,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x16c5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0x15c3(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x1595(%rip),%rsi
lea    0x16d0(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rdi
add    $0x1,%rdi
mov    -0x438(%rbp),%rdx
mov    $0x2,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x1623(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0x1519(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x14eb(%rip),%rsi
lea    0x1626(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rdi
add    $0x3,%rdi
mov    -0x438(%rbp),%rdx
mov    $0x8,%esi
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x1581(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0x146f(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
mov    -0x444(%rbp),%eax
sub    $0xb,%eax
cmp    $0x0,%eax
jle    1c88 <iParseToTrace+0xa68>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x142f(%rip),%rsi
lea    0x156a(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x450(%rbp),%rdi
add    $0xb,%rdi
mov    -0x444(%rbp),%esi
sub    $0xb,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x14c8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0x13af(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
jmp    2392 <iParseToTrace+0x1172>
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
lea    -0x458(%rbp),%rdx
mov    $0x0,%al
call   10c0 <iTlvGetObjByIndex@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
jg     1cdb <iParseToTrace+0xabb>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1481(%rip),%rsi
lea    0x14a2(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
movl   $0x0,-0x46c(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x46c(%rbp),%esi
lea    -0x458(%rbp),%rdx
mov    $0x0,%al
call   10c0 <iTlvGetObjByIndex@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
jg     1d15 <iParseToTrace+0xaf5>
jmp    1d68 <iParseToTrace+0xb48>
mov    -0x8(%rbp),%edi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
mov    $0x1,%esi
xor    %r9d,%r9d
call   10f0 <iParseToTrace@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
je     1d4f <iParseToTrace+0xb2f>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
jmp    1d54 <iParseToTrace+0xb34>
mov    -0x46c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x46c(%rbp)
jmp    1ce5 <iParseToTrace+0xac5>
jmp    2392 <iParseToTrace+0x1172>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10b0 <iTlvCheckTlvObject@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
jl     1d9a <iParseToTrace+0xb7a>
mov    -0x440(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1dc1 <iParseToTrace+0xba1>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0x1271(%rip),%rsi
lea    0x13bc(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
and    $0x20,%eax
cmp    $0x0,%eax
jne    1feb <iParseToTrace+0xdcb>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x1235(%rip),%rsi
lea    0x1370(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4b0(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10d0 <iTlvTagLen@plt>
mov    -0x4b0(%rbp),%rdi
mov    %eax,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x438(%rbp)
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4a8(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10d0 <iTlvTagLen@plt>
mov    %eax,%ecx
mov    -0x4a8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x4a0(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1100 <iTlvLengthLen@plt>
mov    -0x4a0(%rbp),%rdi
mov    %eax,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x438(%rbp)
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10a0 <psTlvValue@plt>
mov    %eax,-0x494(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1090 <iTlvValueLen@plt>
mov    -0x494(%rbp),%edi
mov    %eax,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x1200(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x0,%al
call   1110 <vAddExtraInfo@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,-0x490(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10e0 <psTagAttrGetDesc@plt>
mov    -0x490(%rbp),%rdi
movslq %eax,%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0x1058(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x0,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%edx
lea    0x101e(%rip),%rsi
lea    0x1159(%rip),%rcx
mov    $0x0,%al
call   1120 <sprintf@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4d0(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10d0 <iTlvTagLen@plt>
mov    -0x4d0(%rbp),%rdi
mov    %eax,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x438(%rbp)
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4c8(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10d0 <iTlvTagLen@plt>
mov    %eax,%ecx
mov    -0x4c8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1100 <iTlvLengthLen@plt>
mov    -0x4c0(%rbp),%rdi
mov    %eax,%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0x104d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10e0 <psTagAttrGetDesc@plt>
mov    -0x4b8(%rbp),%rdi
movslq %eax,%rsi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rdx
lea    0xed1(%rip),%rsi
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x0,-0x45c(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x45c(%rbp),%edx
lea    -0x458(%rbp),%rcx
mov    $0x0,%al
call   1130 <iTlvSerachTemplate@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0xffffd8ec,-0x460(%rbp)
d8 ff ff
jne    21a6 <iParseToTrace+0xf86>
jmp    2245 <iParseToTrace+0x1025>
cmpl   $0x0,-0x460(%rbp)
jg     21e0 <iParseToTrace+0xfc0>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
add    -0x43c(%rbp),%edx
lea    0xf93(%rip),%rsi
lea    0xf9d(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x8(%rbp),%edi
mov    -0x458(%rbp),%rdx
mov    -0x460(%rbp),%ecx
mov    -0x20(%rbp),%r8d
add    -0x43c(%rbp),%r8d
mov    -0x24(%rbp),%r9d
add    $0x1,%r9d
mov    $0x1,%esi
call   10f0 <iParseToTrace@plt>
mov    %eax,-0x440(%rbp)
cmpl   $0x0,-0x440(%rbp)
je     222c <iParseToTrace+0x100c>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
jmp    2231 <iParseToTrace+0x1011>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    2170 <iParseToTrace+0xf50>
jmp    224a <iParseToTrace+0x102a>
jmp    2392 <iParseToTrace+0x1172>
lea    -0x430(%rbp),%rax
mov    %rax,-0x438(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    2355 <iParseToTrace+0x1135>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   10b0 <iTlvCheckTlvObject@plt>
mov    %eax,-0x460(%rbp)
cmpl   $0x0,-0x460(%rbp)
jl     2294 <iParseToTrace+0x1074>
mov    -0x460(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    22a0 <iParseToTrace+0x1080>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
mov    -0x438(%rbp),%rdi
movslq -0x20(%rbp),%rdx
mov    $0x2d,%esi
call   1070 <memset@plt>
mov    -0x20(%rbp),%ecx
mov    -0x438(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x460(%rbp),%esi
mov    -0x438(%rbp),%rdx
mov    $0x0,%al
call   1140 <vOneTwo0@plt>
mov    -0x460(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x438(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
lea    0xe59(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x438(%rbp),%rdi
call   1050 <strlen@plt>
add    -0x438(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x460(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x460(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    225d <iParseToTrace+0x103d>
mov    -0x8(%rbp),%edi
lea    -0x430(%rbp),%rsi
mov    $0x0,%al
call   1080 <vTraceWriteTxt@plt>
jmp    2392 <iParseToTrace+0x1172>
mov    -0x8(%rbp),%edi
mov    -0x20(%rbp),%edx
lea    0xdf3(%rip),%rsi
lea    0xdeb(%rip),%rcx
mov    $0x0,%al
call   1060 <vTraceWriteTxtCr@plt>
movl   $0x1,-0x4(%rbp)
jmp    2399 <iParseToTrace+0x1179>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x4d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iParseToTrace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
mov    %r8d,%ebp
mov    %edi,0x8(%rsp)
movb   $0x0,0x20(%rsp)
add    $0xffffffff,%esi
cmp    $0x5,%esi
ja     13c4 <iParseToTrace+0x1a4>
mov    %ecx,%r15d
mov    %rdx,%r13
lea    0xdaa(%rip),%rax
movslq (%rax,%rsi,4),%rcx
add    %rax,%rcx
mov    %ebp,0xc(%rsp)
jmp    *%rcx
mov    %r9d,%r12d
mov    %r13,%rdi
xor    %eax,%eax
call   10b0 <iTlvCheckTlvObject@plt>
test   %eax,%eax
js     1442 <iParseToTrace+0x222>
cmp    %r15d,%eax
jg     1442 <iParseToTrace+0x222>
mov    0x0(%r13),%al
mov    %al,0x18(%rsp)
lea    0xd98(%rip),%rsi
lea    0xec3(%rip),%rcx
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    %ebp,%edx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbx
add    $0x20,%rbx
mov    %r13,%rdi
xor    %eax,%eax
call   10d0 <iTlvTagLen@plt>
mov    %r13,%rdi
mov    %eax,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
lea    (%rbx,%rax,1),%rbp
lea    (%rax,%rbx,1),%r14
add    $0x1,%r14
movb   $0x20,(%rax,%rbx,1)
mov    %r13,%rdi
xor    %eax,%eax
call   10d0 <iTlvTagLen@plt>
movslq %eax,%rbx
add    %r13,%rbx
mov    %r13,%rdi
xor    %eax,%eax
call   1100 <iTlvLengthLen@plt>
mov    %rbx,%rdi
mov    %eax,%esi
mov    %r14,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %r14,%rdi
call   1050 <strlen@plt>
lea    (%rax,%rbp,1),%rbx
add    $0x1,%rbx
testb  $0x20,0x18(%rsp)
jne    1689 <iParseToTrace+0x469>
lea    0x1(%rbx),%rbp
movb   $0x20,(%rbx)
mov    %r13,%rdi
xor    %eax,%eax
call   10a0 <psTlvValue@plt>
mov    %eax,%r14d
mov    %r13,%rdi
xor    %eax,%eax
call   1090 <iTlvValueLen@plt>
mov    %r14d,%edi
mov    %eax,%esi
mov    %rbp,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
lea    (%rbx,%rax,1),%rbp
add    $0x1,%rbp
movl   $0x202f2f20,0x1(%rbx,%rax,1)
20
movb   $0x0,0x5(%rbx,%rax,1)
mov    %rbp,%rdi
call   1050 <strlen@plt>
add    %rax,%rbp
mov    %rbp,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1110 <vAddExtraInfo@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
add    %rax,%rbp
mov    %r13,%rdi
xor    %eax,%eax
call   10e0 <psTagAttrGetDesc@plt>
movslq %eax,%rsi
mov    %rbp,%rdi
call   1030 <strcpy@plt>
lea    0xc7a(%rip),%rsi
lea    0x20(%rsp),%rdx
mov    0x8(%rsp),%edi
jmp    1b91 <iParseToTrace+0x971>
lea    0xd90(%rip),%rsi
jmp    165c <iParseToTrace+0x43c>
mov    %r13,%rdi
xor    %eax,%eax
call   10b0 <iTlvCheckTlvObject@plt>
test   %eax,%eax
js     1442 <iParseToTrace+0x222>
mov    %eax,%ebx
cmp    %r15d,%eax
jg     1442 <iParseToTrace+0x222>
lea    0x10(%rsp),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <iTlvValue@plt>
cmp    $0x1,%ebx
ja     1752 <iParseToTrace+0x532>
lea    0xc2f(%rip),%rsi
jmp    165c <iParseToTrace+0x43c>
mov    %r13,%rdi
xor    %eax,%eax
call   10b0 <iTlvCheckTlvObject@plt>
test   %eax,%eax
js     1442 <iParseToTrace+0x222>
mov    %eax,%ebx
cmp    %r15d,%eax
jg     1442 <iParseToTrace+0x222>
lea    0x10(%rsp),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   1040 <iTlvValue@plt>
cmp    $0xa,%ebx
ja     19ba <iParseToTrace+0x79a>
lea    0xbf6(%rip),%rsi
jmp    1ba6 <iParseToTrace+0x986>
lea    0xbcf(%rip),%rsi
jmp    165c <iParseToTrace+0x43c>
test   %r15d,%r15d
jle    1651 <iParseToTrace+0x431>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
xor    %eax,%eax
call   10d0 <iTlvTagLen@plt>
test   %eax,%eax
jle    1b9f <iParseToTrace+0x97f>
mov    %eax,%ebx
cmp    %eax,%r15d
mov    0xc(%rsp),%edx
jbe    1bba <iParseToTrace+0x99a>
lea    0x1(%rbx),%r12d
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
lea    0xb94(%rip),%rsi
lea    0xcbf(%rip),%rcx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%r14
add    $0x20,%r14
mov    %r13,%rdi
mov    %ebx,%esi
mov    %r14,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %r14,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbp
lea    (%rax,%r14,1),%rdx
add    $0x1,%rdx
movb   $0x20,(%rax,%r14,1)
mov    %ebx,%edi
add    %r13,%rdi
mov    $0x1,%esi
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
lea    (%r14,%rbp,1),%rbx
add    $0x3,%rbx
mov    %r13,%rdi
xor    %eax,%eax
call   10e0 <psTagAttrGetDesc@plt>
mov    %rbx,%rdi
lea    0xb26(%rip),%rsi
mov    %eax,%edx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    0x8(%rsp),%edi
lea    0x20(%rsp),%rsi
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
xor    %ecx,%ecx
mov    %r12d,%eax
add    %rax,%r13
sub    %r12d,%r15d
jg     1460 <iParseToTrace+0x240>
jmp    1675 <iParseToTrace+0x455>
lea    0x10(%rsp),%rdx
mov    %r13,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   10c0 <iTlvGetObjByIndex@plt>
test   %eax,%eax
jle    1655 <iParseToTrace+0x435>
lea    0x10(%rsp),%rdx
mov    %r13,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   10c0 <iTlvGetObjByIndex@plt>
test   %eax,%eax
mov    $0x0,%ecx
jle    1675 <iParseToTrace+0x455>
lea    0x10(%rsp),%rbx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%edi
mov    $0x1,%esi
mov    %r13,%rdx
mov    %r15d,%ecx
mov    0xc(%rsp),%r8d
xor    %r9d,%r9d
call   10f0 <iParseToTrace@plt>
test   %eax,%eax
jne    1670 <iParseToTrace+0x450>
mov    %r13,%rdi
mov    %ebp,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   10c0 <iTlvGetObjByIndex@plt>
xor    %ecx,%ecx
add    $0x1,%ebp
test   %eax,%eax
jg     1580 <iParseToTrace+0x360>
jmp    1675 <iParseToTrace+0x455>
test   %r15d,%r15d
jle    1641 <iParseToTrace+0x421>
lea    0x20(%rsp),%rbx
movslq %ebp,%r14
xchg   %ax,%ax
mov    %r13,%rdi
xor    %eax,%eax
call   10b0 <iTlvCheckTlvObject@plt>
test   %eax,%eax
js     1670 <iParseToTrace+0x450>
mov    %eax,%ebp
cmp    %eax,%r15d
mov    $0x1,%ecx
jl     1675 <iParseToTrace+0x455>
mov    %rbx,%rdi
mov    $0x2d,%esi
mov    %r14,%rdx
call   1070 <memset@plt>
add    %r14,%rbx
mov    %r13,%rdi
mov    %ebp,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
lea    0x0(%rbp,%rbp,1),%eax
cltq
lea    (%rbx,%rax,1),%r12
movw   $0xa0d,(%rax,%rbx,1)
movb   $0x0,0x2(%rax,%rbx,1)
mov    %r12,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbx
add    %r12,%rbx
mov    %ebp,%eax
add    %rax,%r13
sub    %ebp,%r15d
jg     15d0 <iParseToTrace+0x3b0>
lea    0x20(%rsp),%rsi
mov    0x8(%rsp),%edi
xor    %eax,%eax
call   1080 <vTraceWriteTxt@plt>
xor    %ecx,%ecx
jmp    1675 <iParseToTrace+0x455>
lea    0xad6(%rip),%rsi
lea    0xaf7(%rip),%rcx
mov    0x8(%rsp),%edi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
mov    $0x1,%ecx
mov    %ecx,%eax
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movb   $0x0,0x4(%rbx)
movl   $0x202f2f20,(%rbx)
mov    %rbx,%rdi
call   1050 <strlen@plt>
add    %rax,%rbx
mov    %r13,%rdi
xor    %eax,%eax
call   10e0 <psTagAttrGetDesc@plt>
movslq %eax,%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0x976(%rip),%rsi
lea    0x20(%rsp),%rdx
mov    0x8(%rsp),%edi
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
lea    0x10(%rsp),%rcx
mov    %r13,%rdi
mov    %r15d,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1130 <iTlvSerachTemplate@plt>
cmp    $0xffffd8ec,%eax
mov    $0x0,%ecx
je     1675 <iParseToTrace+0x455>
addl   $0x4,0xc(%rsp)
add    $0x1,%r12d
mov    $0x1,%ebx
lea    0x10(%rsp),%rbp
test   %eax,%eax
jle    1c8b <iParseToTrace+0xa6b>
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%edi
mov    $0x1,%esi
mov    %eax,%ecx
mov    0xc(%rsp),%r8d
mov    %r12d,%r9d
call   10f0 <iParseToTrace@plt>
mov    $0x1,%ecx
test   %eax,%eax
jne    1675 <iParseToTrace+0x455>
mov    %r13,%rdi
mov    %r15d,%esi
mov    %ebx,%edx
mov    %rbp,%rcx
xor    %eax,%eax
call   1130 <iTlvSerachTemplate@plt>
xor    %ecx,%ecx
add    $0x1,%ebx
cmp    $0xffffd8ec,%eax
jne    16fd <iParseToTrace+0x4dd>
jmp    1675 <iParseToTrace+0x455>
mov    %eax,%r14d
lea    0x8cc(%rip),%rsi
lea    0x9f7(%rip),%rcx
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    %ebp,%edx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbp
add    $0x20,%rbp
mov    0x10(%rsp),%rdi
mov    $0x2,%esi
mov    %rbp,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
lea    (%rax,%rbp,1),%rbx
movabs $0x7075535b202f2f20,%rcx
53 75 70
mov    %rcx,(%rax,%rbp,1)
movabs $0x3a74726f707075,%rcx
mov    %rcx,0x6(%rax,%rbp,1)
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbp
add    %rbx,%rbp
mov    0x10(%rsp),%rax
mov    (%rax),%cl
test   $0x40,%cl
jne    1bd1 <iParseToTrace+0x9b1>
test   $0x20,%cl
jne    1be7 <iParseToTrace+0x9c7>
test   $0x10,%cl
jne    1bfd <iParseToTrace+0x9dd>
test   $0x8,%cl
jne    1c1e <iParseToTrace+0x9fe>
test   $0x4,%cl
jne    1c3f <iParseToTrace+0xa1f>
test   $0x1,%cl
jne    1c66 <iParseToTrace+0xa46>
cmpb   $0x0,0x1(%rax)
js     1c7b <iParseToTrace+0xa5b>
mov    %rbp,%rdi
call   1050 <strlen@plt>
movl   $0x4941205d,0x0(%rbp,%rax,1)
49
movw   $0x50,0x4(%rbp,%rax,1)
lea    0x20(%rsp),%rsi
mov    0x8(%rsp),%edi
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
xor    %ecx,%ecx
cmp    $0x6,%r14d
jl     1675 <iParseToTrace+0x455>
add    $0xfffffffe,%r14d
shr    $0x2,%r14d
mov    $0x2,%r15d
xor    %r13d,%r13d
lea    0x20(%rsp),%rbp
mov    %r14,0x18(%rsp)
jmp    18ac <iParseToTrace+0x68c>
cs nopw 0x0(%rax,%rax,1)
mov    0x18(%rsp),%r14
mov    %rbp,%rdi
lea    0x88b(%rip),%rsi
mov    %r13d,%edx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    0x8(%rsp),%edi
lea    0x20(%rsp),%rsi
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
xor    %ecx,%ecx
add    $0x1,%r13
add    $0x4,%r15
cmp    %r13,%r14
je     1675 <iParseToTrace+0x455>
mov    0x10(%rsp),%r14
lea    (%r14,%r15,1),%r12
mov    %rbp,%rdi
lea    0x769(%rip),%rsi
mov    0xc(%rsp),%edx
lea    0x890(%rip),%rcx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbx
add    %rbp,%rbx
mov    %r12,%rdi
mov    $0x4,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
lea    (%rbx,%rax,1),%rbp
movl   $0x202f2f20,(%rax,%rbx,1)
movw   $0x5b,0x4(%rax,%rbx,1)
mov    %rbp,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbx
add    %rbp,%rbx
movzbl 0x2(%r14,%r13,4),%edx
shr    $0x3,%edx
mov    %rbx,%rdi
lea    0x798(%rip),%rsi
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbp
add    %rbx,%rbp
movzbl 0x3(%r14,%r13,4),%edx
mov    %rbp,%rdi
lea    0x77a(%rip),%rsi
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbx
add    %rbp,%rbx
movzbl 0x4(%r14,%r13,4),%edx
mov    %rbx,%rdi
lea    0x76a(%rip),%rsi
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
mov    %rax,%rbp
add    %rbx,%rbp
movzbl 0x5(%r14,%r13,4),%edx
test   %edx,%edx
je     1870 <iParseToTrace+0x650>
mov    %rbp,%rdi
lea    0x751(%rip),%rsi
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
add    %rax,%rbp
jmp    1870 <iParseToTrace+0x650>
mov    %eax,%r14d
lea    0x664(%rip),%rsi
lea    0x78f(%rip),%r15
lea    0x20(%rsp),%r12
mov    %r12,%rdi
mov    0xc(%rsp),%r13d
mov    %r13d,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbx
add    $0x20,%rbx
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
movabs $0x444943202f2f20,%rcx
mov    %rcx,(%rax,%rbx,1)
lea    0x60a(%rip),%rsi
mov    0x8(%rsp),%ebp
mov    %ebp,%edi
mov    %r12,%rdx
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
mov    %r12,%rdi
lea    0x5e8(%rip),%rsi
mov    %r13d,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbx
add    $0x20,%rbx
mov    0x10(%rsp),%rdi
add    $0x1,%rdi
mov    $0x2,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
movabs $0x435441202f2f20,%rcx
mov    %rcx,(%rax,%rbx,1)
mov    %ebp,%edi
lea    0x59c(%rip),%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
mov    %r12,%rdi
lea    0x580(%rip),%rsi
mov    %r13d,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbx
add    $0x20,%rbx
mov    0x10(%rsp),%rdi
add    $0x3,%rdi
mov    $0x8,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
movl   $0x202f2f20,(%rax,%rbx,1)
movl   $0x434120,0x3(%rax,%rbx,1)
mov    %ebp,%edi
lea    0x533(%rip),%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
xor    %ecx,%ecx
cmp    $0xc,%r14d
jl     1675 <iParseToTrace+0x455>
add    $0xfffffff5,%r14d
lea    0x50a(%rip),%rsi
lea    0x635(%rip),%rcx
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    0xc(%rsp),%edx
xor    %eax,%eax
call   1120 <sprintf@plt>
mov    %rbp,%rdi
call   1050 <strlen@plt>
lea    (%rsp,%rax,1),%rbx
add    $0x20,%rbx
mov    0x10(%rsp),%rdi
add    $0xb,%rdi
mov    %r14d,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1140 <vOneTwo0@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
movabs $0x28444149202f2f20,%rcx
41 44 28
mov    %rcx,(%rax,%rbx,1)
movabs $0x29303146395428,%rcx
mov    %rcx,0x7(%rax,%rbx,1)
lea    0x4a6(%rip),%rsi
mov    0x8(%rsp),%edi
mov    %rbp,%rdx
xor    %eax,%eax
call   1060 <vTraceWriteTxtCr@plt>
xor    %ecx,%ecx
jmp    1675 <iParseToTrace+0x455>
lea    0x472(%rip),%rsi
lea    0x5ad(%rip),%rcx
mov    0x8(%rsp),%edi
mov    0xc(%rsp),%edx
jmp    1669 <iParseToTrace+0x449>
lea    0x457(%rip),%rsi
lea    0x592(%rip),%rcx
mov    0x8(%rsp),%edi
jmp    1669 <iParseToTrace+0x449>
movb   $0x0,0x4(%rbp)
movl   $0x41445320,0x0(%rbp)
mov    (%rax),%cl
test   $0x20,%cl
je     17e8 <iParseToTrace+0x5c8>
movb   $0x0,0x4(%rbp)
movl   $0x41444420,0x0(%rbp)
mov    (%rax),%cl
test   $0x10,%cl
je     17f1 <iParseToTrace+0x5d1>
movups 0x473(%rip),%xmm0
movups %xmm0,0xa(%rbp)
movups 0x45e(%rip),%xmm0
movups %xmm0,0x0(%rbp)
mov    (%rax),%cl
test   $0x8,%cl
je     17fa <iParseToTrace+0x5da>
movups 0x46c(%rip),%xmm0
movups %xmm0,0xa(%rbp)
movups 0x457(%rip),%xmm0
movups %xmm0,0x0(%rbp)
mov    (%rax),%cl
test   $0x4,%cl
je     1803 <iParseToTrace+0x5e3>
movabs $0x68747561207265,%rcx
mov    %rcx,0x5(%rbp)
movabs $0x2072657573734920,%rcx
65 72 20
mov    %rcx,0x0(%rbp)
mov    (%rax),%cl
test   $0x1,%cl
je     180c <iParseToTrace+0x5ec>
movb   $0x0,0x4(%rbp)
movl   $0x41444320,0x0(%rbp)
cmpb   $0x0,0x1(%rax)
jns    1816 <iParseToTrace+0x5f6>
movb   $0x0,0x4(%rbp)
movl   $0x44534d20,0x0(%rbp)
jmp    1816 <iParseToTrace+0x5f6>
lea    0x4b7(%rip),%rsi
jmp    1ba6 <iParseToTrace+0x986>

LLVM IR (-O0):
@.str = [16 x i8] c"%*sFormat error\00"
@.str.1 = [1 x i8] zeroinitializer
@.str.2 = [4 x i8] c"%*s\00"
@.str.3 = [7 x i8] c" // %s\00"
@.str.4 = [34 x i8] c"%*sFormat error, less data length\00"
@.str.5 = [14 x i8] c" // [Support:\00"
@.str.6 = [5 x i8] c" SDA\00"
@.str.7 = [5 x i8] c" DDA\00"
@.str.8 = [26 x i8] c" Card holder verification\00"
@.str.9 = [26 x i8] c" Terminal risk management\00"
@.str.10 = [13 x i8] c" Issuer auth\00"
@.str.11 = [5 x i8] c" CDA\00"
@.str.12 = [5 x i8] c" MSD\00"
@.str.13 = [6 x i8] c"] AIP\00"
@.str.14 = [6 x i8] c" // [\00"
@.str.15 = [7 x i8] c"SFI:%d\00"
@.str.16 = [21 x i8] c" First Record No.:%d\00"
@.str.17 = [20 x i8] c" Last Record No.:%d\00"
@.str.18 = [22 x i8] c" Need to be signed:%d\00"
@.str.19 = [18 x i8] c"] // AFL Entry %d\00"
@.str.20 = [8 x i8] c" // CID\00"
@.str.21 = [3 x i8] c"%s\00"
@.str.22 = [8 x i8] c" // ATC\00"
@.str.23 = [7 x i8] c" // AC\00"
@.str.24 = [15 x i8] c" // IAD(T9F10)\00"
@.str.25 = [18 x i8] c"%*sTlv DB is empy\00"
@.str.26 = [5 x i8] c" // \00"
@.str.27 = [15 x i8] c"%*sParse error\00"
@.str.28 = [3 x i8] c"\0D\0A\00"
@.str.29 = [21 x i8] c"%*sUnknown info type\00"
define i32 @iParseToTrace(i32 %0, i32 %1, i8* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [1024 x i8]
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i8*
%24 = alloca i32
%25 = alloca i32
store i32 %0, i32* %8
store i32 %1, i32* %9
store i8* %2, i8** %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 4, i32* %16
%26 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8 0, i8* %26
%27 = load i32, i32* %9
switch i32 %27, label %672 [
i32 4, label %28
i32 2, label %94
i32 3, label %308
i32 5, label %421
i32 1, label %452
i32 6, label %623
]
28: ; preds = %6
br label %29
29: ; preds = %50, %28
%30 = load i32, i32* %11
%31 = icmp sgt i32 %30, 0
br i1 %31, label %32, label %93
32: ; preds = %29
%33 = load i8*, i8** %10
%34 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %33)
store i32 %34, i32* %25
%35 = load i32, i32* %25
%36 = icmp sle i32 %35, 0
br i1 %36, label %37, label %41
37: ; preds = %32
%38 = load i32, i32* %8
%39 = load i32, i32* %12
%40 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %38, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %39, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
41: ; preds = %32
%42 = load i32, i32* %11
%43 = load i32, i32* %25
%44 = add nsw i32 %43, 1
%45 = icmp slt i32 %42, %44
br i1 %45, label %46, label %50
46: ; preds = %41
%47 = load i32, i32* %8
%48 = load i32, i32* %12
%49 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %47, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %48, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
50: ; preds = %41
%51 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %51, i8** %15
%52 = load i8*, i8** %15
%53 = load i32, i32* %12
%54 = call i32 (i8*, i8*, ...) @sprintf(i8* %52, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %53, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%55 = load i8*, i8** %15
%56 = call i64 @strlen(i8* %55)
%57 = load i8*, i8** %15
%58 = getelementptr inbounds i8, i8* %57, i64 %56
store i8* %58, i8** %15
%59 = load i8*, i8** %10
%60 = load i32, i32* %25
%61 = load i8*, i8** %15
%62 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %59, i32 %60, i8* %61)
%63 = load i8*, i8** %15
%64 = call i64 @strlen(i8* %63)
%65 = load i8*, i8** %15
%66 = getelementptr inbounds i8, i8* %65, i64 %64
store i8* %66, i8** %15
%67 = load i8*, i8** %15
%68 = getelementptr inbounds i8, i8* %67, i32 1
store i8* %68, i8** %15
store i8 32, i8* %67
%69 = load i8*, i8** %10
%70 = load i32, i32* %25
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8*, i8** %15
%74 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %72, i32 1, i8* %73)
%75 = load i8*, i8** %15
%76 = getelementptr inbounds i8, i8* %75, i64 2
store i8* %76, i8** %15
%77 = load i8*, i8** %15
%78 = load i8*, i8** %10
%79 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %78)
%80 = call i32 (i8*, i8*, ...) @sprintf(i8* %77, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %79)
%81 = load i32, i32* %8
%82 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%83 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %81, i8* %82)
%84 = load i32, i32* %25
%85 = add nsw i32 %84, 1
%86 = load i8*, i8** %10
%87 = sext i32 %85 to i64
%88 = getelementptr inbounds i8, i8* %86, i64 %87
store i8* %88, i8** %10
%89 = load i32, i32* %25
%90 = add nsw i32 %89, 1
%91 = load i32, i32* %11
%92 = sub nsw i32 %91, %90
store i32 %92, i32* %11
br label %29
93: ; preds = %29
br label %676
94: ; preds = %6
%95 = load i8*, i8** %10
%96 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %95)
store i32 %96, i32* %17
%97 = load i32, i32* %17
%98 = icmp slt i32 %97, 0
br i1 %98, label %103, label %99
99: ; preds = %94
%100 = load i32, i32* %17
%101 = load i32, i32* %11
%102 = icmp sgt i32 %100, %101
br i1 %102, label %103, label %107
103: ; preds = %99, %94
%104 = load i32, i32* %8
%105 = load i32, i32* %12
%106 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %104, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %105, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
107: ; preds = %99
%108 = load i8*, i8** %10
%109 = call i32 (i8*, i8**, ...) bitcast (i32 (...)* @iTlvValue to i32 (i8*, i8**, ...)*)(i8* %108, i8** %19)
store i32 %109, i32* %18
%110 = load i32, i32* %17
%111 = icmp slt i32 %110, 2
br i1 %111, label %112, label %116
112: ; preds = %107
%113 = load i32, i32* %8
%114 = load i32, i32* %12
%115 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %113, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %114, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
116: ; preds = %107
%117 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %117, i8** %15
%118 = load i8*, i8** %15
%119 = load i32, i32* %12
%120 = call i32 (i8*, i8*, ...) @sprintf(i8* %118, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %119, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%121 = load i8*, i8** %15
%122 = call i64 @strlen(i8* %121)
%123 = load i8*, i8** %15
%124 = getelementptr inbounds i8, i8* %123, i64 %122
store i8* %124, i8** %15
%125 = load i8*, i8** %19
%126 = load i8*, i8** %15
%127 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %125, i32 2, i8* %126)
%128 = load i8*, i8** %15
%129 = call i64 @strlen(i8* %128)
%130 = load i8*, i8** %15
%131 = getelementptr inbounds i8, i8* %130, i64 %129
store i8* %131, i8** %15
%132 = load i8*, i8** %15
%133 = call i8* @strcpy(i8* %132, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0))
%134 = load i8*, i8** %15
%135 = call i64 @strlen(i8* %134)
%136 = load i8*, i8** %15
%137 = getelementptr inbounds i8, i8* %136, i64 %135
store i8* %137, i8** %15
%138 = load i8*, i8** %19
%139 = getelementptr inbounds i8, i8* %138, i64 0
%140 = load i8, i8* %139
%141 = zext i8 %140 to i32
%142 = and i32 %141, 64
%143 = icmp ne i32 %142, 0
br i1 %143, label %144, label %147
144: ; preds = %116
%145 = load i8*, i8** %15
%146 = call i8* @strcpy(i8* %145, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
br label %147
147: ; preds = %144, %116
%148 = load i8*, i8** %19
%149 = getelementptr inbounds i8, i8* %148, i64 0
%150 = load i8, i8* %149
%151 = zext i8 %150 to i32
%152 = and i32 %151, 32
%153 = icmp ne i32 %152, 0
br i1 %153, label %154, label %157
154: ; preds = %147
%155 = load i8*, i8** %15
%156 = call i8* @strcpy(i8* %155, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
br label %157
157: ; preds = %154, %147
%158 = load i8*, i8** %19
%159 = getelementptr inbounds i8, i8* %158, i64 0
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = and i32 %161, 16
%163 = icmp ne i32 %162, 0
br i1 %163, label %164, label %167
164: ; preds = %157
%165 = load i8*, i8** %15
%166 = call i8* @strcpy(i8* %165, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0))
br label %167
167: ; preds = %164, %157
%168 = load i8*, i8** %19
%169 = getelementptr inbounds i8, i8* %168, i64 0
%170 = load i8, i8* %169
%171 = zext i8 %170 to i32
%172 = and i32 %171, 8
%173 = icmp ne i32 %172, 0
br i1 %173, label %174, label %177
174: ; preds = %167
%175 = load i8*, i8** %15
%176 = call i8* @strcpy(i8* %175, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.9, i64 0, i64 0))
br label %177
177: ; preds = %174, %167
%178 = load i8*, i8** %19
%179 = getelementptr inbounds i8, i8* %178, i64 0
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = and i32 %181, 4
%183 = icmp ne i32 %182, 0
br i1 %183, label %184, label %187
184: ; preds = %177
%185 = load i8*, i8** %15
%186 = call i8* @strcpy(i8* %185, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i64 0, i64 0))
br label %187
187: ; preds = %184, %177
%188 = load i8*, i8** %19
%189 = getelementptr inbounds i8, i8* %188, i64 0
%190 = load i8, i8* %189
%191 = zext i8 %190 to i32
%192 = and i32 %191, 1
%193 = icmp ne i32 %192, 0
br i1 %193, label %194, label %197
194: ; preds = %187
%195 = load i8*, i8** %15
%196 = call i8* @strcpy(i8* %195, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
br label %197
197: ; preds = %194, %187
%198 = load i8*, i8** %19
%199 = getelementptr inbounds i8, i8* %198, i64 1
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = and i32 %201, 128
%203 = icmp ne i32 %202, 0
br i1 %203, label %204, label %207
204: ; preds = %197
%205 = load i8*, i8** %15
%206 = call i8* @strcpy(i8* %205, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0))
br label %207
207: ; preds = %204, %197
%208 = load i8*, i8** %15
%209 = call i64 @strlen(i8* %208)
%210 = load i8*, i8** %15
%211 = getelementptr inbounds i8, i8* %210, i64 %209
store i8* %211, i8** %15
%212 = load i8*, i8** %15
%213 = call i8* @strcpy(i8* %212, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
%214 = load i32, i32* %8
%215 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%216 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %214, i8* %215)
%217 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %217, i8** %15
store i32 0, i32* %24
br label %218
218: ; preds = %304, %207
%219 = load i32, i32* %24
%220 = load i32, i32* %18
%221 = sub nsw i32 %220, 2
%222 = sdiv i32 %221, 4
%223 = icmp slt i32 %219, %222
br i1 %223, label %224, label %307
224: ; preds = %218
%225 = load i8*, i8** %19
%226 = getelementptr inbounds i8, i8* %225, i64 2
%227 = load i32, i32* %24
%228 = mul nsw i32 %227, 4
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %226, i64 %229
store i8* %230, i8** %23
%231 = load i8*, i8** %15
%232 = load i32, i32* %12
%233 = call i32 (i8*, i8*, ...) @sprintf(i8* %231, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %232, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%234 = load i8*, i8** %15
%235 = call i64 @strlen(i8* %234)
%236 = load i8*, i8** %15
%237 = getelementptr inbounds i8, i8* %236, i64 %235
store i8* %237, i8** %15
%238 = load i8*, i8** %23
%239 = load i8*, i8** %15
%240 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %238, i32 4, i8* %239)
%241 = load i8*, i8** %15
%242 = call i64 @strlen(i8* %241)
%243 = load i8*, i8** %15
%244 = getelementptr inbounds i8, i8* %243, i64 %242
store i8* %244, i8** %15
%245 = load i8*, i8** %15
%246 = call i8* @strcpy(i8* %245, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
%247 = load i8*, i8** %15
%248 = call i64 @strlen(i8* %247)
%249 = load i8*, i8** %15
%250 = getelementptr inbounds i8, i8* %249, i64 %248
store i8* %250, i8** %15
%251 = load i8*, i8** %15
%252 = load i8*, i8** %23
%253 = getelementptr inbounds i8, i8* %252, i64 0
%254 = load i8, i8* %253
%255 = zext i8 %254 to i32
%256 = ashr i32 %255, 3
%257 = call i32 (i8*, i8*, ...) @sprintf(i8* %251, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %256)
%258 = load i8*, i8** %15
%259 = call i64 @strlen(i8* %258)
%260 = load i8*, i8** %15
%261 = getelementptr inbounds i8, i8* %260, i64 %259
store i8* %261, i8** %15
%262 = load i8*, i8** %15
%263 = load i8*, i8** %23
%264 = getelementptr inbounds i8, i8* %263, i64 1
%265 = load i8, i8* %264
%266 = zext i8 %265 to i32
%267 = call i32 (i8*, i8*, ...) @sprintf(i8* %262, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), i32 %266)
%268 = load i8*, i8** %15
%269 = call i64 @strlen(i8* %268)
%270 = load i8*, i8** %15
%271 = getelementptr inbounds i8, i8* %270, i64 %269
store i8* %271, i8** %15
%272 = load i8*, i8** %15
%273 = load i8*, i8** %23
%274 = getelementptr inbounds i8, i8* %273, i64 2
%275 = load i8, i8* %274
%276 = zext i8 %275 to i32
%277 = call i32 (i8*, i8*, ...) @sprintf(i8* %272, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.17, i64 0, i64 0), i32 %276)
%278 = load i8*, i8** %15
%279 = call i64 @strlen(i8* %278)
%280 = load i8*, i8** %15
%281 = getelementptr inbounds i8, i8* %280, i64 %279
store i8* %281, i8** %15
%282 = load i8*, i8** %23
%283 = getelementptr inbounds i8, i8* %282, i64 3
%284 = load i8, i8* %283
%285 = icmp ne i8 %284, 0
br i1 %285, label %286, label %297
286: ; preds = %224
%287 = load i8*, i8** %15
%288 = load i8*, i8** %23
%289 = getelementptr inbounds i8, i8* %288, i64 3
%290 = load i8, i8* %289
%291 = zext i8 %290 to i32
%292 = call i32 (i8*, i8*, ...) @sprintf(i8* %287, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), i32 %291)
%293 = load i8*, i8** %15
%294 = call i64 @strlen(i8* %293)
%295 = load i8*, i8** %15
%296 = getelementptr inbounds i8, i8* %295, i64 %294
store i8* %296, i8** %15
br label %297
297: ; preds = %286, %224
%298 = load i8*, i8** %15
%299 = load i32, i32* %24
%300 = call i32 (i8*, i8*, ...) @sprintf(i8* %298, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.19, i64 0, i64 0), i32 %299)
%301 = load i32, i32* %8
%302 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%303 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %301, i8* %302)
br label %304
304: ; preds = %297
%305 = load i32, i32* %24
%306 = add nsw i32 %305, 1
store i32 %306, i32* %24
br label %218
307: ; preds = %218
br label %676
308: ; preds = %6
%309 = load i8*, i8** %10
%310 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %309)
store i32 %310, i32* %17
%311 = load i32, i32* %17
%312 = icmp slt i32 %311, 0
br i1 %312, label %317, label %313
313: ; preds = %308
%314 = load i32, i32* %17
%315 = load i32, i32* %11
%316 = icmp sgt i32 %314, %315
br i1 %316, label %317, label %321
317: ; preds = %313, %308
%318 = load i32, i32* %8
%319 = load i32, i32* %12
%320 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %318, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %319, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
321: ; preds = %313
%322 = load i8*, i8** %10
%323 = call i32 (i8*, i8**, ...) bitcast (i32 (...)* @iTlvValue to i32 (i8*, i8**, ...)*)(i8* %322, i8** %19)
store i32 %323, i32* %18
%324 = load i32, i32* %17
%325 = icmp slt i32 %324, 11
br i1 %325, label %326, label %330
326: ; preds = %321
%327 = load i32, i32* %8
%328 = load i32, i32* %12
%329 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %327, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %328, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
330: ; preds = %321
%331 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %331, i8** %15
%332 = load i8*, i8** %15
%333 = load i32, i32* %12
%334 = call i32 (i8*, i8*, ...) @sprintf(i8* %332, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %333, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%335 = load i8*, i8** %15
%336 = call i64 @strlen(i8* %335)
%337 = load i8*, i8** %15
%338 = getelementptr inbounds i8, i8* %337, i64 %336
store i8* %338, i8** %15
%339 = load i8*, i8** %19
%340 = load i8*, i8** %15
%341 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %339, i32 1, i8* %340)
%342 = load i8*, i8** %15
%343 = call i64 @strlen(i8* %342)
%344 = load i8*, i8** %15
%345 = getelementptr inbounds i8, i8* %344, i64 %343
store i8* %345, i8** %15
%346 = load i8*, i8** %15
%347 = call i8* @strcpy(i8* %346, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i64 0, i64 0))
%348 = load i32, i32* %8
%349 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%350 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %348, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %349)
%351 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %351, i8** %15
%352 = load i8*, i8** %15
%353 = load i32, i32* %12
%354 = call i32 (i8*, i8*, ...) @sprintf(i8* %352, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %353, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%355 = load i8*, i8** %15
%356 = call i64 @strlen(i8* %355)
%357 = load i8*, i8** %15
%358 = getelementptr inbounds i8, i8* %357, i64 %356
store i8* %358, i8** %15
%359 = load i8*, i8** %19
%360 = getelementptr inbounds i8, i8* %359, i64 1
%361 = load i8*, i8** %15
%362 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %360, i32 2, i8* %361)
%363 = load i8*, i8** %15
%364 = call i64 @strlen(i8* %363)
%365 = load i8*, i8** %15
%366 = getelementptr inbounds i8, i8* %365, i64 %364
store i8* %366, i8** %15
%367 = load i8*, i8** %15
%368 = call i8* @strcpy(i8* %367, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.22, i64 0, i64 0))
%369 = load i32, i32* %8
%370 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%371 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %369, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %370)
%372 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %372, i8** %15
%373 = load i8*, i8** %15
%374 = load i32, i32* %12
%375 = call i32 (i8*, i8*, ...) @sprintf(i8* %373, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %374, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%376 = load i8*, i8** %15
%377 = call i64 @strlen(i8* %376)
%378 = load i8*, i8** %15
%379 = getelementptr inbounds i8, i8* %378, i64 %377
store i8* %379, i8** %15
%380 = load i8*, i8** %19
%381 = getelementptr inbounds i8, i8* %380, i64 3
%382 = load i8*, i8** %15
%383 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %381, i32 8, i8* %382)
%384 = load i8*, i8** %15
%385 = call i64 @strlen(i8* %384)
%386 = load i8*, i8** %15
%387 = getelementptr inbounds i8, i8* %386, i64 %385
store i8* %387, i8** %15
%388 = load i8*, i8** %15
%389 = call i8* @strcpy(i8* %388, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0))
%390 = load i32, i32* %8
%391 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%392 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %390, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %391)
%393 = load i32, i32* %18
%394 = sub nsw i32 %393, 11
%395 = icmp sgt i32 %394, 0
br i1 %395, label %396, label %420
396: ; preds = %330
%397 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %397, i8** %15
%398 = load i8*, i8** %15
%399 = load i32, i32* %12
%400 = call i32 (i8*, i8*, ...) @sprintf(i8* %398, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %399, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%401 = load i8*, i8** %15
%402 = call i64 @strlen(i8* %401)
%403 = load i8*, i8** %15
%404 = getelementptr inbounds i8, i8* %403, i64 %402
store i8* %404, i8** %15
%405 = load i8*, i8** %19
%406 = getelementptr inbounds i8, i8* %405, i64 11
%407 = load i32, i32* %18
%408 = sub nsw i32 %407, 11
%409 = load i8*, i8** %15
%410 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %406, i32 %408, i8* %409)
%411 = load i8*, i8** %15
%412 = call i64 @strlen(i8* %411)
%413 = load i8*, i8** %15
%414 = getelementptr inbounds i8, i8* %413, i64 %412
store i8* %414, i8** %15
%415 = load i8*, i8** %15
%416 = call i8* @strcpy(i8* %415, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.24, i64 0, i64 0))
%417 = load i32, i32* %8
%418 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%419 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %417, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %418)
br label %420
420: ; preds = %396, %330
br label %676
421: ; preds = %6
%422 = load i8*, i8** %10
%423 = call i32 (i8*, i32, i8**, ...) bitcast (i32 (...)* @iTlvGetObjByIndex to i32 (i8*, i32, i8**, ...)*)(i8* %422, i32 0, i8** %20)
store i32 %423, i32* %17
%424 = load i32, i32* %17
%425 = icmp sle i32 %424, 0
br i1 %425, label %426, label %430
426: ; preds = %421
%427 = load i32, i32* %8
%428 = load i32, i32* %12
%429 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %427, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.25, i64 0, i64 0), i32 %428, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
430: ; preds = %421
store i32 0, i32* %24
br label %431
431: ; preds = %448, %430
%432 = load i8*, i8** %10
%433 = load i32, i32* %24
%434 = call i32 (i8*, i32, i8**, ...) bitcast (i32 (...)* @iTlvGetObjByIndex to i32 (i8*, i32, i8**, ...)*)(i8* %432, i32 %433, i8** %20)
store i32 %434, i32* %17
%435 = load i32, i32* %17
%436 = icmp sle i32 %435, 0
br i1 %436, label %437, label %438
437: ; preds = %431
br label %451
438: ; preds = %431
%439 = load i32, i32* %8
%440 = load i8*, i8** %10
%441 = load i32, i32* %11
%442 = load i32, i32* %12
%443 = call i32 @iParseToTrace(i32 %439, i32 1, i8* %440, i32 %441, i32 %442, i32 0)
store i32 %443, i32* %17
%444 = load i32, i32* %17
%445 = icmp ne i32 %444, 0
br i1 %445, label %446, label %447
446: ; preds = %438
store i32 1, i32* %7
br label %677
447: ; preds = %438
br label %448
448: ; preds = %447
%449 = load i32, i32* %24
%450 = add nsw i32 %449, 1
store i32 %450, i32* %24
br label %431
451: ; preds = %437
br label %676
452: ; preds = %6
%453 = load i8*, i8** %10
%454 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %453)
store i32 %454, i32* %17
%455 = load i32, i32* %17
%456 = icmp slt i32 %455, 0
br i1 %456, label %461, label %457
457: ; preds = %452
%458 = load i32, i32* %17
%459 = load i32, i32* %11
%460 = icmp sgt i32 %458, %459
br i1 %460, label %461, label %465
461: ; preds = %457, %452
%462 = load i32, i32* %8
%463 = load i32, i32* %12
%464 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %462, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %463, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
465: ; preds = %457
%466 = load i8*, i8** %10
%467 = getelementptr inbounds i8, i8* %466, i64 0
%468 = load i8, i8* %467
%469 = zext i8 %468 to i32
%470 = and i32 %469, 32
%471 = icmp eq i32 %470, 0
br i1 %471, label %472, label %539
472: ; preds = %465
%473 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %473, i8** %15
%474 = load i8*, i8** %15
%475 = load i32, i32* %12
%476 = call i32 (i8*, i8*, ...) @sprintf(i8* %474, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %475, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%477 = load i8*, i8** %15
%478 = call i64 @strlen(i8* %477)
%479 = load i8*, i8** %15
%480 = getelementptr inbounds i8, i8* %479, i64 %478
store i8* %480, i8** %15
%481 = load i8*, i8** %10
%482 = load i8*, i8** %10
%483 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %482)
%484 = load i8*, i8** %15
%485 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %481, i32 %483, i8* %484)
%486 = load i8*, i8** %15
%487 = call i64 @strlen(i8* %486)
%488 = load i8*, i8** %15
%489 = getelementptr inbounds i8, i8* %488, i64 %487
store i8* %489, i8** %15
%490 = load i8*, i8** %15
%491 = getelementptr inbounds i8, i8* %490, i32 1
store i8* %491, i8** %15
store i8 32, i8* %490
%492 = load i8*, i8** %10
%493 = load i8*, i8** %10
%494 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %493)
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds i8, i8* %492, i64 %495
%497 = load i8*, i8** %10
%498 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvLengthLen to i32 (i8*, ...)*)(i8* %497)
%499 = load i8*, i8** %15
%500 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %496, i32 %498, i8* %499)
%501 = load i8*, i8** %15
%502 = call i64 @strlen(i8* %501)
%503 = load i8*, i8** %15
%504 = getelementptr inbounds i8, i8* %503, i64 %502
store i8* %504, i8** %15
%505 = load i8*, i8** %15
%506 = getelementptr inbounds i8, i8* %505, i32 1
store i8* %506, i8** %15
store i8 32, i8* %505
%507 = load i8*, i8** %10
%508 = call i32 (i8*, ...) bitcast (i32 (...)* @psTlvValue to i32 (i8*, ...)*)(i8* %507)
%509 = load i8*, i8** %10
%510 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvValueLen to i32 (i8*, ...)*)(i8* %509)
%511 = load i8*, i8** %15
%512 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i32, i32, i8*, ...)*)(i32 %508, i32 %510, i8* %511)
%513 = load i8*, i8** %15
%514 = call i64 @strlen(i8* %513)
%515 = load i8*, i8** %15
%516 = getelementptr inbounds i8, i8* %515, i64 %514
store i8* %516, i8** %15
%517 = load i8*, i8** %15
%518 = call i8* @strcpy(i8* %517, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0))
%519 = load i8*, i8** %15
%520 = call i64 @strlen(i8* %519)
%521 = load i8*, i8** %15
%522 = getelementptr inbounds i8, i8* %521, i64 %520
store i8* %522, i8** %15
%523 = load i8*, i8** %15
%524 = load i8*, i8** %10
%525 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @vAddExtraInfo to i32 (i8*, i8*, ...)*)(i8* %523, i8* %524)
%526 = load i8*, i8** %15
%527 = call i64 @strlen(i8* %526)
%528 = load i8*, i8** %15
%529 = getelementptr inbounds i8, i8* %528, i64 %527
store i8* %529, i8** %15
%530 = load i8*, i8** %15
%531 = load i8*, i8** %10
%532 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %531)
%533 = sext i32 %532 to i64
%534 = inttoptr i64 %533 to i8*
%535 = call i8* @strcpy(i8* %530, i8* %534)
%536 = load i32, i32* %8
%537 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%538 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %536, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %537)
store i32 0, i32* %7
br label %677
539: ; preds = %465
%540 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %540, i8** %15
%541 = load i8*, i8** %15
%542 = load i32, i32* %12
%543 = call i32 (i8*, i8*, ...) @sprintf(i8* %541, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %542, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%544 = load i8*, i8** %15
%545 = call i64 @strlen(i8* %544)
%546 = load i8*, i8** %15
%547 = getelementptr inbounds i8, i8* %546, i64 %545
store i8* %547, i8** %15
%548 = load i8*, i8** %10
%549 = load i8*, i8** %10
%550 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %549)
%551 = load i8*, i8** %15
%552 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %548, i32 %550, i8* %551)
%553 = load i8*, i8** %15
%554 = call i64 @strlen(i8* %553)
%555 = load i8*, i8** %15
%556 = getelementptr inbounds i8, i8* %555, i64 %554
store i8* %556, i8** %15
%557 = load i8*, i8** %15
%558 = getelementptr inbounds i8, i8* %557, i32 1
store i8* %558, i8** %15
store i8 32, i8* %557
%559 = load i8*, i8** %10
%560 = load i8*, i8** %10
%561 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %560)
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i8, i8* %559, i64 %562
%564 = load i8*, i8** %10
%565 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvLengthLen to i32 (i8*, ...)*)(i8* %564)
%566 = load i8*, i8** %15
%567 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %563, i32 %565, i8* %566)
%568 = load i8*, i8** %15
%569 = call i64 @strlen(i8* %568)
%570 = load i8*, i8** %15
%571 = getelementptr inbounds i8, i8* %570, i64 %569
store i8* %571, i8** %15
%572 = load i8*, i8** %15
%573 = call i8* @strcpy(i8* %572, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0))
%574 = load i8*, i8** %15
%575 = call i64 @strlen(i8* %574)
%576 = load i8*, i8** %15
%577 = getelementptr inbounds i8, i8* %576, i64 %575
store i8* %577, i8** %15
%578 = load i8*, i8** %15
%579 = load i8*, i8** %10
%580 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %579)
%581 = sext i32 %580 to i64
%582 = inttoptr i64 %581 to i8*
%583 = call i8* @strcpy(i8* %578, i8* %582)
%584 = load i32, i32* %8
%585 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%586 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %584, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %585)
store i32 0, i32* %21
br label %587
587: ; preds = %618, %539
%588 = load i8*, i8** %10
%589 = load i32, i32* %11
%590 = load i32, i32* %21
%591 = call i32 (i8*, i32, i32, i8**, ...) bitcast (i32 (...)* @iTlvSerachTemplate to i32 (i8*, i32, i32, i8**, ...)*)(i8* %588, i32 %589, i32 %590, i8** %20)
store i32 %591, i32* %22
%592 = load i32, i32* %22
%593 = icmp eq i32 %592, -10004
br i1 %593, label %594, label %595
594: ; preds = %587
br label %621
595: ; preds = %587
%596 = load i32, i32* %22
%597 = icmp sle i32 %596, 0
br i1 %597, label %598, label %604
598: ; preds = %595
%599 = load i32, i32* %8
%600 = load i32, i32* %12
%601 = load i32, i32* %16
%602 = add nsw i32 %600, %601
%603 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %599, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.27, i64 0, i64 0), i32 %602, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
604: ; preds = %595
%605 = load i32, i32* %8
%606 = load i8*, i8** %20
%607 = load i32, i32* %22
%608 = load i32, i32* %12
%609 = load i32, i32* %16
%610 = add nsw i32 %608, %609
%611 = load i32, i32* %13
%612 = add nsw i32 %611, 1
%613 = call i32 @iParseToTrace(i32 %605, i32 1, i8* %606, i32 %607, i32 %610, i32 %612)
store i32 %613, i32* %17
%614 = load i32, i32* %17
%615 = icmp ne i32 %614, 0
br i1 %615, label %616, label %617
616: ; preds = %604
store i32 1, i32* %7
br label %677
617: ; preds = %604
br label %618
618: ; preds = %617
%619 = load i32, i32* %21
%620 = add nsw i32 %619, 1
store i32 %620, i32* %21
br label %587
621: ; preds = %594
br label %622
622: ; preds = %621
br label %676
623: ; preds = %6
%624 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
store i8* %624, i8** %15
br label %625
625: ; preds = %638, %623
%626 = load i32, i32* %11
%627 = icmp sgt i32 %626, 0
br i1 %627, label %628, label %668
628: ; preds = %625
%629 = load i8*, i8** %10
%630 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %629)
store i32 %630, i32* %22
%631 = load i32, i32* %22
%632 = icmp slt i32 %631, 0
br i1 %632, label %637, label %633
633: ; preds = %628
%634 = load i32, i32* %22
%635 = load i32, i32* %11
%636 = icmp sgt i32 %634, %635
br i1 %636, label %637, label %638
637: ; preds = %633, %628
store i32 1, i32* %7
br label %677
638: ; preds = %633
%639 = load i8*, i8** %15
%640 = load i32, i32* %12
%641 = sext i32 %640 to i64
%642 = load i32, i32* %12
%643 = load i8*, i8** %15
%644 = sext i32 %642 to i64
%645 = getelementptr inbounds i8, i8* %643, i64 %644
store i8* %645, i8** %15
%646 = load i8*, i8** %10
%647 = load i32, i32* %22
%648 = load i8*, i8** %15
%649 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %646, i32 %647, i8* %648)
%650 = load i32, i32* %22
%651 = mul nsw i32 %650, 2
%652 = load i8*, i8** %15
%653 = sext i32 %651 to i64
%654 = getelementptr inbounds i8, i8* %652, i64 %653
store i8* %654, i8** %15
%655 = load i8*, i8** %15
%656 = call i8* @strcpy(i8* %655, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.28, i64 0, i64 0))
%657 = load i8*, i8** %15
%658 = call i64 @strlen(i8* %657)
%659 = load i8*, i8** %15
%660 = getelementptr inbounds i8, i8* %659, i64 %658
store i8* %660, i8** %15
%661 = load i32, i32* %22
%662 = load i32, i32* %11
%663 = sub nsw i32 %662, %661
store i32 %663, i32* %11
%664 = load i32, i32* %22
%665 = load i8*, i8** %10
%666 = sext i32 %664 to i64
%667 = getelementptr inbounds i8, i8* %665, i64 %666
store i8* %667, i8** %10
br label %625
668: ; preds = %625
%669 = load i32, i32* %8
%670 = getelementptr inbounds [1024 x i8], [1024 x i8]* %14, i64 0, i64 0
%671 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxt to i32 (i32, i8*, ...)*)(i32 %669, i8* %670)
br label %676
672: ; preds = %6
%673 = load i32, i32* %8
%674 = load i32, i32* %12
%675 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %673, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.29, i64 0, i64 0), i32 %674, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %7
br label %677
676: ; preds = %668, %622, %451, %420, %307, %93
store i32 0, i32* %7
br label %677
677: ; preds = %676, %672, %637, %616, %598, %472, %461, %446, %426, %326, %317, %112, %103, %46, %37
%678 = load i32, i32* %7
ret i32 %678
}

LLVM IR (-O2):
@.str = [16 x i8] c"%*sFormat error\00"
@.str.1 = [1 x i8] zeroinitializer
@.str.2 = [4 x i8] c"%*s\00"
@.str.3 = [7 x i8] c" // %s\00"
@.str.4 = [34 x i8] c"%*sFormat error, less data length\00"
@.str.5 = [14 x i8] c" // [Support:\00"
@.str.6 = [5 x i8] c" SDA\00"
@.str.7 = [5 x i8] c" DDA\00"
@.str.8 = [26 x i8] c" Card holder verification\00"
@.str.9 = [26 x i8] c" Terminal risk management\00"
@.str.10 = [13 x i8] c" Issuer auth\00"
@.str.11 = [5 x i8] c" CDA\00"
@.str.12 = [5 x i8] c" MSD\00"
@.str.13 = [6 x i8] c"] AIP\00"
@.str.14 = [6 x i8] c" // [\00"
@.str.15 = [7 x i8] c"SFI:%d\00"
@.str.16 = [21 x i8] c" First Record No.:%d\00"
@.str.17 = [20 x i8] c" Last Record No.:%d\00"
@.str.18 = [22 x i8] c" Need to be signed:%d\00"
@.str.19 = [18 x i8] c"] // AFL Entry %d\00"
@.str.21 = [3 x i8] c"%s\00"
@.str.23 = [7 x i8] c" // AC\00"
@.str.24 = [15 x i8] c" // IAD(T9F10)\00"
@.str.25 = [18 x i8] c"%*sTlv DB is empy\00"
@.str.26 = [5 x i8] c" // \00"
@.str.27 = [15 x i8] c"%*sParse error\00"
@.str.28 = [3 x i8] c"\0D\0A\00"
@.str.29 = [21 x i8] c"%*sUnknown info type\00"
define i32 @iParseToTrace(i32 %0, i32 %1, i8* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [1024 x i8]
%8 = alloca i8*
%9 = alloca i8*
%10 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 0
%11 = bitcast i8** %8 to i8*
%12 = bitcast i8** %9 to i8*
store i8 0, i8* %10
switch i32 %1, label %330 [
i32 4, label %17
i32 2, label %50
i32 3, label %169
i32 5, label %222
i32 1, label %238
i32 6, label %13
]
13: ; preds = %6
%14 = icmp sgt i32 %3, 0
br i1 %14, label %15, label %328
15: ; preds = %13
%16 = sext i32 %4 to i64
br label %308
17: ; preds = %6
%18 = icmp sgt i32 %3, 0
br i1 %18, label %19, label %332
19: ; preds = %17, %31
%20 = phi i8* [ %47, %31 ], [ %2, %17 ]
%21 = phi i32 [ %48, %31 ], [ %3, %17 ]
%22 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %20)
%23 = icmp slt i32 %22, 1
br i1 %23, label %24, label %26
24: ; preds = %19
%25 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
26: ; preds = %19
%27 = add nuw nsw i32 %22, 1
%28 = icmp ugt i32 %21, %22
br i1 %28, label %31, label %29
29: ; preds = %26
%30 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
31: ; preds = %26
%32 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%33 = call i64 @strlen(i8* %10)
%34 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %33
%35 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %20, i32 %22, i8* %34)
%36 = call i64 @strlen(i8* %34)
%37 = getelementptr inbounds i8, i8* %34, i64 %36
%38 = getelementptr inbounds i8, i8* %37, i64 1
store i8 32, i8* %37
%39 = zext i32 %22 to i64
%40 = getelementptr inbounds i8, i8* %20, i64 %39
%41 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %40, i32 1, i8* %38)
%42 = getelementptr inbounds i8, i8* %38, i64 2
%43 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %20)
%44 = call i32 (i8*, i8*, ...) @sprintf(i8* %42, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i32 %43)
%45 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %0, i8* %10)
%46 = zext i32 %27 to i64
%47 = getelementptr inbounds i8, i8* %20, i64 %46
%48 = sub nsw i32 %21, %27
%49 = icmp sgt i32 %48, 0
br i1 %49, label %19, label %332
50: ; preds = %6
%51 = tail call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %2)
%52 = icmp slt i32 %51, 0
%53 = icmp sgt i32 %51, %3
%54 = or i1 %52, %53
br i1 %54, label %55, label %57
55: ; preds = %50
%56 = tail call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
57: ; preds = %50
%58 = call i32 (i8*, i8**, ...) bitcast (i32 (...)* @iTlvValue to i32 (i8*, i8**, ...)*)(i8* %2, i8** %8)
%59 = icmp ult i32 %51, 2
br i1 %59, label %60, label %62
60: ; preds = %57
%61 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
62: ; preds = %57
%63 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%64 = call i64 @strlen(i8* %10)
%65 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %64
%66 = load i8*, i8** %8
%67 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %66, i32 2, i8* %65)
%68 = call i64 @strlen(i8* %65)
%69 = getelementptr inbounds i8, i8* %65, i64 %68
%70 = call i64 @strlen(i8* %69)
%71 = getelementptr inbounds i8, i8* %69, i64 %70
%72 = load i8*, i8** %8
%73 = load i8, i8* %72
%74 = and i8 %73, 64
%75 = icmp eq i8 %74, 0
br i1 %75, label %78, label %76
76: ; preds = %62
%77 = load i8, i8* %72
br label %78
78: ; preds = %76, %62
%79 = phi i8 [ %77, %76 ], [ %73, %62 ]
%80 = and i8 %79, 32
%81 = icmp eq i8 %80, 0
br i1 %81, label %84, label %82
82: ; preds = %78
%83 = load i8, i8* %72
br label %84
84: ; preds = %82, %78
%85 = phi i8 [ %83, %82 ], [ %79, %78 ]
%86 = and i8 %85, 16
%87 = icmp eq i8 %86, 0
br i1 %87, label %90, label %88
88: ; preds = %84
%89 = load i8, i8* %72
br label %90
90: ; preds = %88, %84
%91 = phi i8 [ %89, %88 ], [ %85, %84 ]
%92 = and i8 %91, 8
%93 = icmp eq i8 %92, 0
br i1 %93, label %96, label %94
94: ; preds = %90
%95 = load i8, i8* %72
br label %96
96: ; preds = %94, %90
%97 = phi i8 [ %95, %94 ], [ %91, %90 ]
%98 = and i8 %97, 4
%99 = icmp eq i8 %98, 0
br i1 %99, label %102, label %100
100: ; preds = %96
%101 = load i8, i8* %72
br label %102
102: ; preds = %100, %96
%103 = phi i8 [ %101, %100 ], [ %97, %96 ]
%104 = and i8 %103, 1
%105 = icmp eq i8 %104, 0
br i1 %105, label %107, label %106
106: ; preds = %102
br label %107
107: ; preds = %106, %102
%108 = getelementptr inbounds i8, i8* %72, i64 1
%109 = load i8, i8* %108
%110 = icmp sgt i8 %109, -1
br i1 %110, label %112, label %111
111: ; preds = %107
br label %112
112: ; preds = %111, %107
%113 = call i64 @strlen(i8* %71)
%114 = getelementptr inbounds i8, i8* %71, i64 %113
%115 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %0, i8* %10)
%116 = icmp sgt i32 %58, 5
br i1 %116, label %117, label %332
117: ; preds = %112
%118 = add nsw i32 %58, -2
%119 = lshr i32 %118, 2
%120 = zext i32 %119 to i64
br label %121
121: ; preds = %117, %162
%122 = phi i64 [ 0, %117 ], [ %167, %162 ]
%123 = phi i8* [ %10, %117 ], [ %163, %162 ]
%124 = load i8*, i8** %8
%125 = getelementptr inbounds i8, i8* %124, i64 2
%126 = shl nsw i64 %122, 2
%127 = getelementptr inbounds i8, i8* %125, i64 %126
%128 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %123, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%129 = call i64 @strlen(i8* dereferenceable(1) %123)
%130 = getelementptr inbounds i8, i8* %123, i64 %129
%131 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %127, i32 4, i8* %130)
%132 = call i64 @strlen(i8* dereferenceable(1) %130)
%133 = getelementptr inbounds i8, i8* %130, i64 %132
%134 = call i64 @strlen(i8* dereferenceable(1) %133)
%135 = getelementptr inbounds i8, i8* %133, i64 %134
%136 = load i8, i8* %127
%137 = lshr i8 %136, 3
%138 = zext i8 %137 to i32
%139 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %135, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0), i32 %138)
%140 = call i64 @strlen(i8* dereferenceable(1) %135)
%141 = getelementptr inbounds i8, i8* %135, i64 %140
%142 = getelementptr inbounds i8, i8* %127, i64 1
%143 = load i8, i8* %142
%144 = zext i8 %143 to i32
%145 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %141, i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.16, i64 0, i64 0), i32 %144)
%146 = call i64 @strlen(i8* dereferenceable(1) %141)
%147 = getelementptr inbounds i8, i8* %141, i64 %146
%148 = getelementptr inbounds i8, i8* %127, i64 2
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %147, i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.17, i64 0, i64 0), i32 %150)
%152 = call i64 @strlen(i8* dereferenceable(1) %147)
%153 = getelementptr inbounds i8, i8* %147, i64 %152
%154 = getelementptr inbounds i8, i8* %127, i64 3
%155 = load i8, i8* %154
%156 = icmp eq i8 %155, 0
br i1 %156, label %162, label %157
157: ; preds = %121
%158 = zext i8 %155 to i32
%159 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %153, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), i32 %158)
%160 = call i64 @strlen(i8* dereferenceable(1) %153)
%161 = getelementptr inbounds i8, i8* %153, i64 %160
br label %162
162: ; preds = %157, %121
%163 = phi i8* [ %161, %157 ], [ %153, %121 ]
%164 = trunc i64 %122 to i32
%165 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %163, i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.19, i64 0, i64 0), i32 %164)
%166 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, ...)*)(i32 %0, i8* %10)
%167 = add nuw nsw i64 %122, 1
%168 = icmp eq i64 %167, %120
br i1 %168, label %332, label %121
169: ; preds = %6
%170 = tail call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %2)
%171 = icmp slt i32 %170, 0
%172 = icmp sgt i32 %170, %3
%173 = or i1 %171, %172
br i1 %173, label %174, label %176
174: ; preds = %169
%175 = tail call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
176: ; preds = %169
%177 = call i32 (i8*, i8**, ...) bitcast (i32 (...)* @iTlvValue to i32 (i8*, i8**, ...)*)(i8* %2, i8** %8)
%178 = icmp ult i32 %170, 11
br i1 %178, label %179, label %181
179: ; preds = %176
%180 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.4, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
181: ; preds = %176
%182 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%183 = call i64 @strlen(i8* %10)
%184 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %183
%185 = load i8*, i8** %8
%186 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %185, i32 1, i8* %184)
%187 = call i64 @strlen(i8* %184)
%188 = getelementptr inbounds i8, i8* %184, i64 %187
%189 = bitcast i8* %188 to i64*
store i64 19220851067924256, i64* %189
%190 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
%191 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%192 = call i64 @strlen(i8* %10)
%193 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %192
%194 = load i8*, i8** %8
%195 = getelementptr inbounds i8, i8* %194, i64 1
%196 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %195, i32 2, i8* %193)
%197 = call i64 @strlen(i8* %193)
%198 = getelementptr inbounds i8, i8* %193, i64 %197
%199 = bitcast i8* %198 to i64*
store i64 18951462129184544, i64* %199
%200 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
%201 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%202 = call i64 @strlen(i8* %10)
%203 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %202
%204 = load i8*, i8** %8
%205 = getelementptr inbounds i8, i8* %204, i64 3
%206 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %205, i32 8, i8* %203)
%207 = call i64 @strlen(i8* %203)
%208 = getelementptr inbounds i8, i8* %203, i64 %207
%209 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
%210 = icmp sgt i32 %177, 11
br i1 %210, label %211, label %332
211: ; preds = %181
%212 = add nsw i32 %177, -11
%213 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%214 = call i64 @strlen(i8* %10)
%215 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %214
%216 = load i8*, i8** %8
%217 = getelementptr inbounds i8, i8* %216, i64 11
%218 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %217, i32 %212, i8* %215)
%219 = call i64 @strlen(i8* %215)
%220 = getelementptr inbounds i8, i8* %215, i64 %219
%221 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
br label %332
222: ; preds = %6
%223 = call i32 (i8*, i32, i8**, ...) bitcast (i32 (...)* @iTlvGetObjByIndex to i32 (i8*, i32, i8**, ...)*)(i8* %2, i32 0, i8** %9)
%224 = icmp slt i32 %223, 1
br i1 %224, label %228, label %225
225: ; preds = %222
%226 = call i32 (i8*, i32, i8**, ...) bitcast (i32 (...)* @iTlvGetObjByIndex to i32 (i8*, i32, i8**, ...)*)(i8* %2, i32 0, i8** %9)
%227 = icmp slt i32 %226, 1
br i1 %227, label %332, label %233
228: ; preds = %222
%229 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.25, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
230: ; preds = %233
%231 = call i32 (i8*, i32, i8**, ...) bitcast (i32 (...)* @iTlvGetObjByIndex to i32 (i8*, i32, i8**, ...)*)(i8* %2, i32 %237, i8** %9)
%232 = icmp slt i32 %231, 1
br i1 %232, label %332, label %233
233: ; preds = %225, %230
%234 = phi i32 [ %237, %230 ], [ 0, %225 ]
%235 = call i32 @iParseToTrace(i32 %0, i32 1, i8* %2, i32 %3, i32 %4, i32 0)
%236 = icmp eq i32 %235, 0
%237 = add nuw nsw i32 %234, 1
br i1 %236, label %230, label %332
238: ; preds = %6
%239 = tail call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %2)
%240 = icmp slt i32 %239, 0
%241 = icmp sgt i32 %239, %3
%242 = or i1 %240, %241
br i1 %242, label %243, label %245
243: ; preds = %238
%244 = tail call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
245: ; preds = %238
%246 = load i8, i8* %2
%247 = and i8 %246, 32
%248 = icmp eq i8 %247, 0
%249 = call i32 (i8*, i8*, ...) @sprintf(i8* %10, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
%250 = call i64 @strlen(i8* %10)
%251 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 %250
%252 = tail call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %2)
%253 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %2, i32 %252, i8* %251)
%254 = call i64 @strlen(i8* %251)
%255 = getelementptr inbounds i8, i8* %251, i64 %254
%256 = getelementptr inbounds i8, i8* %255, i64 1
store i8 32, i8* %255
%257 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvTagLen to i32 (i8*, ...)*)(i8* %2)
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %2, i64 %258
%260 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvLengthLen to i32 (i8*, ...)*)(i8* %2)
%261 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %259, i32 %260, i8* %256)
%262 = call i64 @strlen(i8* %256)
%263 = getelementptr inbounds i8, i8* %256, i64 %262
br i1 %248, label %264, label %281
264: ; preds = %245
%265 = getelementptr inbounds i8, i8* %263, i64 1
store i8 32, i8* %263
%266 = call i32 (i8*, ...) bitcast (i32 (...)* @psTlvValue to i32 (i8*, ...)*)(i8* %2)
%267 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvValueLen to i32 (i8*, ...)*)(i8* %2)
%268 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i32, i32, i8*, ...)*)(i32 %266, i32 %267, i8* %265)
%269 = call i64 @strlen(i8* %265)
%270 = getelementptr inbounds i8, i8* %265, i64 %269
%271 = call i64 @strlen(i8* %270)
%272 = getelementptr inbounds i8, i8* %270, i64 %271
%273 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @vAddExtraInfo to i32 (i8*, i8*, ...)*)(i8* %272, i8* %2)
%274 = call i64 @strlen(i8* %272)
%275 = getelementptr inbounds i8, i8* %272, i64 %274
%276 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %2)
%277 = sext i32 %276 to i64
%278 = inttoptr i64 %277 to i8*
%279 = call i8* @strcpy(i8* %275, i8* dereferenceable(1) %278)
%280 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
br label %332
281: ; preds = %245
%282 = call i64 @strlen(i8* %263)
%283 = getelementptr inbounds i8, i8* %263, i64 %282
%284 = call i32 (i8*, ...) bitcast (i32 (...)* @psTagAttrGetDesc to i32 (i8*, ...)*)(i8* %2)
%285 = sext i32 %284 to i64
%286 = inttoptr i64 %285 to i8*
%287 = call i8* @strcpy(i8* %283, i8* dereferenceable(1) %286)
%288 = call i32 (i32, i8*, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %10)
%289 = call i32 (i8*, i32, i32, i8**, ...) bitcast (i32 (...)* @iTlvSerachTemplate to i32 (i8*, i32, i32, i8**, ...)*)(i8* %2, i32 %3, i32 0, i8** %9)
%290 = icmp eq i32 %289, -10004
br i1 %290, label %332, label %291
291: ; preds = %281
%292 = add nsw i32 %4, 4
%293 = add nsw i32 %5, 1
br label %297
294: ; preds = %303
%295 = call i32 (i8*, i32, i32, i8**, ...) bitcast (i32 (...)* @iTlvSerachTemplate to i32 (i8*, i32, i32, i8**, ...)*)(i8* %2, i32 %3, i32 %307, i8** %9)
%296 = icmp eq i32 %295, -10004
br i1 %296, label %332, label %297
297: ; preds = %291, %294
%298 = phi i32 [ %289, %291 ], [ %295, %294 ]
%299 = phi i32 [ 0, %291 ], [ %307, %294 ]
%300 = icmp slt i32 %298, 1
br i1 %300, label %301, label %303
301: ; preds = %297
%302 = call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.27, i64 0, i64 0), i32 %292, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
303: ; preds = %297
%304 = load i8*, i8** %9
%305 = call i32 @iParseToTrace(i32 %0, i32 1, i8* %304, i32 %298, i32 %292, i32 %293)
%306 = icmp eq i32 %305, 0
%307 = add nuw nsw i32 %299, 1
br i1 %306, label %294, label %332
308: ; preds = %15, %316
%309 = phi i8* [ %2, %15 ], [ %326, %316 ]
%310 = phi i32 [ %3, %15 ], [ %324, %316 ]
%311 = phi i8* [ %10, %15 ], [ %323, %316 ]
%312 = call i32 (i8*, ...) bitcast (i32 (...)* @iTlvCheckTlvObject to i32 (i8*, ...)*)(i8* %309)
%313 = icmp slt i32 %312, 0
%314 = icmp slt i32 %310, %312
%315 = select i1 %313, i1 true, i1 %314
br i1 %315, label %332, label %316
316: ; preds = %308
%317 = getelementptr inbounds i8, i8* %311, i64 %16
%318 = call i32 (i8*, i32, i8*, ...) bitcast (i32 (...)* @vOneTwo0 to i32 (i8*, i32, i8*, ...)*)(i8* %309, i32 %312, i8* %317)
%319 = shl nuw nsw i32 %312, 1
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i8, i8* %317, i64 %320
%322 = call i64 @strlen(i8* dereferenceable(1) %321)
%323 = getelementptr inbounds i8, i8* %321, i64 %322
%324 = sub nsw i32 %310, %312
%325 = zext i32 %312 to i64
%326 = getelementptr inbounds i8, i8* %309, i64 %325
%327 = icmp sgt i32 %324, 0
br i1 %327, label %308, label %328
328: ; preds = %316, %13
%329 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxt to i32 (i32, i8*, ...)*)(i32 %0, i8* %10)
br label %332
330: ; preds = %6
%331 = tail call i32 (i32, i8*, i32, i8*, ...) bitcast (i32 (...)* @vTraceWriteTxtCr to i32 (i32, i8*, i32, i8*, ...)*)(i32 %0, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.29, i64 0, i64 0), i32 %4, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
br label %332
332: ; preds = %308, %303, %294, %233, %230, %162, %31, %281, %225, %112, %17, %29, %24, %328, %211, %181, %330, %301, %264, %243, %228, %179, %174, %60, %55
%333 = phi i32 [ 1, %330 ], [ 1, %243 ], [ 0, %264 ], [ 1, %301 ], [ 1, %228 ], [ 1, %174 ], [ 1, %179 ], [ 1, %55 ], [ 1, %60 ], [ 0, %181 ], [ 0, %211 ], [ 0, %328 ], [ 1, %24 ], [ 1, %29 ], [ 0, %17 ], [ 0, %112 ], [ 0, %225 ], [ 0, %281 ], [ 0, %31 ], [ 0, %162 ], [ 0, %230 ], [ 1, %233 ], [ 0, %294 ], [ 1, %303 ], [ 1, %308 ]
ret i32 %333
}