[MS Demangler] Demangle string literals

[zturner]

Summary

String literals are pretty interesting... undname, when it encounters a string literal, just prints string. For example:

$ undname ??_C@_0CF@LABBIIMO@012345678901234567890123456789AB@
Microsoft (R) C++ Name Undecorator
Copyright (C) Microsoft Corporation. All rights reserved.

Undecoration of :- "??_C@_0CF@LABBIIMO@012345678901234567890123456789AB@"
is :- "`string'"

I wanted to do better and print the actual string. So, for example, in the above example, I want to print const char * {"012345678901234567890123456789AB"...} (where the ... indicates the string was truncated).

There are a couple of gotchas here.

1. The mangling is not unique. It is possible to produce, for example, a const char * a const char16_t *, and a const char32_t * that all mangle the same.

2. The mangling is lossy. It only encodes a maximum of 32 bytes (for char, char16_t, and char32_t) and 32 characters (for wchar_t), which means any characters after that get truncated.

The biggest challenging is trying to infer the character byte size (i.e. is it a char, char16_t, or char32_t) (the mangling scheme uniquely identifies wchar_t, so this one is not a problem). We employ some heuristics based on counting null terminators or embedded nulls and make a best effort guess. It works well for all cases I tested, but probably for unicode strings it will break down. That said, even if it does fail to correctly deduce the character type, it will just fall back to printing the string as const char* with escaped characters. So it won't be incorrect, just sub-optimal.

You can see some sample output by examining the test file I checked in, which was ported from clang/test/CodeGenCXX/mangle-ms-string-literals.cpp

[rnk]

lgtm

llvm/lib/Demangle/MicrosoftDemangle.cpp

1638–1643 ↗

(On Diff #160911)

lol.

[majnemer]

LGTM

llvm/trunk/lib/Demangle/MicrosoftDemangle.cpp

 };
 
 enum NameBackrefBehavior : uint8_t {
   NBB_None = 0,          // don't save any names as backrefs.
   NBB_Template = 1 << 0, // save template instanations.
   NBB_Simple = 1 << 1,   // save simple names.
 };
 
-enum class SymbolCategory { Function, Variable, Unknown };
+enum class SymbolCategory { Unknown, Function, Variable, StringLiteral };
 
 namespace {
 
 struct NameResolver {
   virtual ~NameResolver() = default;
   virtual StringView resolve(StringView S) = 0;
 };
 

 };
 
 // Represents an identifier which may be a template.
 struct Name {
   bool IsTemplateInstantiation = false;
   bool IsOperator = false;
   bool IsBackReference = false;
   bool IsConversionOperator = false;
+  bool IsStringLiteral = false;
+  bool IsLongStringLiteral = false;
+
+  // If IsStringLiteral is true, this is the character type.
+  PrimTy StringLiteralType = PrimTy::None;
 
   // Name read from an MangledName string.
   StringView Str;
 
   // Template parameters. Only valid if Flags contains NF_TemplateInstantiation.
   TemplateParams *TParams = nullptr;
 
   // Nested BackReferences (e.g. "A::B::C") are represented as a linked list.
while (Head) {
 
     Head = Head->Next;
 
     if (Head)
       OS << ", ";
   }
 }
 
+static void outputStringLiteral(OutputStream &OS, const Name &TheString) {
+  assert(TheString.IsStringLiteral);
+  switch (TheString.StringLiteralType) {
+  case PrimTy::Wchar:
+    OS << "const wchar_t * {L\"";
+    break;
+  case PrimTy::Char:
+    OS << "const char * {\"";
+    break;
+  case PrimTy::Char16:
+    OS << "const char16_t * {u\"";
+    break;
+  case PrimTy::Char32:
+    OS << "const char32_t * {U\"";
+    break;
+  default:
+    LLVM_BUILTIN_UNREACHABLE;
+  }
+  OS << TheString.Str << "\"";
+  if (TheString.IsLongStringLiteral)
+    OS << "...";
+  OS << "}";
+}
+
 static void outputName(OutputStream &OS, const Name *TheName, const Type *Ty,
                        NameResolver &Resolver);
 
 static void outputParameterList(OutputStream &OS, const TemplateParams &Params,
                                 NameResolver &Resolver) {
   if (Params.IsEmptyParameterPack) {
     OS << "<>";
     return;
private:
 
   Name *demangleBackRefName(StringView &MangledName);
   Name *demangleTemplateInstantiationName(StringView &MangledName,
                                           NameBackrefBehavior NBB);
   Name *demangleOperatorName(StringView &MangledName);
   Name *demangleSimpleName(StringView &MangledName, bool Memorize);
   Name *demangleAnonymousNamespaceName(StringView &MangledName);
   Name *demangleLocallyScopedNamePiece(StringView &MangledName);
+  Name *demangleStringLiteral(StringView &MangledName);
 
   StringView demangleSimpleString(StringView &MangledName, bool Memorize);
 
   FuncClass demangleFunctionClass(StringView &MangledName);
   CallingConv demangleCallingConvention(StringView &MangledName);
   StorageClass demangleVariableStorageClass(StringView &MangledName);
   ReferenceKind demangleReferenceKind(StringView &MangledName);
   void demangleThrowSpecification(StringView &MangledName);
+  wchar_t demangleWcharLiteral(StringView &MangledName);
+  uint8_t demangleCharLiteral(StringView &MangledName);
 
   std::pair<Qualifiers, bool> demangleQualifiers(StringView &MangledName);
 
   // Memory allocator.
   ArenaAllocator Arena;
 
   // A single type uses one global back-ref table for all function params.
   // This means back-refs can even go "into" other types.  Examples:

 Symbol *Demangler::parse(StringView &MangledName) {
   Symbol *S = Arena.alloc<Symbol>();
 
   // We can't demangle MD5 names, just output them as-is.
   if (MangledName.startsWith("??@")) {
     S->Category = SymbolCategory::Unknown;
     S->SymbolName = Arena.alloc<Name>();
     S->SymbolName->Str = MangledName;
+    S->SymbolType = nullptr;
     MangledName = StringView();
     return S;
   }
 
   // MSVC-style mangled symbols must start with '?'.
   if (!MangledName.consumeFront("?")) {
+    S->Category = SymbolCategory::Unknown;
     S->SymbolName = Arena.alloc<Name>();
     S->SymbolName->Str = MangledName;
-    S->SymbolType = Arena.alloc<Type>();
-    S->SymbolType->Prim = PrimTy::Unknown;
+    S->SymbolType = nullptr;
+    return S;
+  }
+
+  if (MangledName.consumeFront("?_C@_")) {
+    // This is a string literal.  Just demangle it and return.
+    S->Category = SymbolCategory::StringLiteral;
+    S->SymbolName = demangleStringLiteral(MangledName);
+    S->SymbolType = nullptr;
     return S;
   }
 
   // What follows is a main symbol name. This may include
   // namespaces or class BackReferences.
   S->SymbolName = demangleFullyQualifiedSymbolName(MangledName);
   if (Error)
     return nullptr;
case '_': {
       case '3':
         return "<<=";
       case '4':
         return "&=";
       case '5':
         return "|=";
       case '6':
         return "^=";
+      // case '7': # vftable
+      // case '8': # vbtable
+      // case '9': # vcall
+      // case 'A': # typeof
+      // case 'B': # local static guard
+      // case 'D': # vbase destructor
+      // case 'E': # vector deleting destructor
+      // case 'F': # default constructor closure
+      // case 'G': # scalar deleting destructor
+      // case 'H': # vector constructor iterator
+      // case 'I': # vector destructor iterator
+      // case 'J': # vector vbase constructor iterator
+      // case 'K': # virtual displacement map
+      // case 'L': # eh vector constructor iterator
+      // case 'M': # eh vector destructor iterator
+      // case 'N': # eh vector vbase constructor iterator
+      // case 'O': # copy constructor closure
+      // case 'P<name>': # udt returning <name>
+      // case 'Q': # <unknown>
+      // case 'R0': # RTTI Type Descriptor
+      // case 'R1': # RTTI Base Class Descriptor at (a,b,c,d)
+      // case 'R2': # RTTI Base Class Array
+      // case 'R3': # RTTI Class Hierarchy Descriptor
+      // case 'R4': # RTTI Complete Object Locator
+      // case 'S': # local vftable
+      // case 'T': # local vftable constructor closure
       case 'U':
         return " new[]";
       case 'V':
         return " delete[]";
       case '_':
         if (MangledName.consumeFront("L"))
           return " co_await";
         if (MangledName.consumeFront("K")) {
Name *Demangler::demangleOperatorName(StringView &MangledName) {
 
   Name *Node = Arena.alloc<Name>();
   if (MangledName.consumeFront('B')) {
     // Handle conversion operator specially.
     Node->IsConversionOperator = true;
   } else {
     Node->Str = NameString();
   }
+  if (Error)
+    return nullptr;
+
   Node->IsOperator = true;
   return Node;
 }
 
 Name *Demangler::demangleSimpleName(StringView &MangledName, bool Memorize) {
   StringView S = demangleSimpleString(MangledName, Memorize);
   if (Error)
     return nullptr;
 
   Name *Node = Arena.alloc<Name>();
   Node->Str = S;
   return Node;
 }
 
+static bool isRebasedHexDigit(char C) { return (C >= 'A' && C <= 'P'); }
+
+static uint8_t rebasedHexDigitToNumber(char C) {
+  assert(isRebasedHexDigit(C));
+  return (C <= 'J') ? (C - 'A') : (10 + C - 'K');
+}
+
+uint8_t Demangler::demangleCharLiteral(StringView &MangledName) {
+  if (!MangledName.startsWith('?'))
+    return MangledName.popFront();
+
+  MangledName = MangledName.dropFront();
+  if (MangledName.empty())
+    goto CharLiteralError;
+
+  if (MangledName.consumeFront('$')) {
+    // Two hex digits
+    if (MangledName.size() < 2)
+      goto CharLiteralError;
+    StringView Nibbles = MangledName.substr(0, 2);
+    if (!isRebasedHexDigit(Nibbles[0]) || !isRebasedHexDigit(Nibbles[1]))
+      goto CharLiteralError;
+    // Don't append the null terminator.
+    uint8_t C1 = rebasedHexDigitToNumber(Nibbles[0]);
+    uint8_t C2 = rebasedHexDigitToNumber(Nibbles[1]);
+    MangledName = MangledName.dropFront(2);
+    return (C1 << 4) | C2;
+  }
+
+  if (startsWithDigit(MangledName)) {
+    const char *Lookup = ",/\\:. \n\t'-";
+    char C = Lookup[MangledName[0] - '0'];
+    MangledName = MangledName.dropFront();
+    return C;
+  }
+
+  if (MangledName[0] >= 'a' && MangledName[0] <= 'z') {
+    char Lookup[26] = {'\xE1', '\xE2', '\xE3', '\xE4', '\xE5', '\xE6', '\xE7',
+                       '\xE8', '\xE9', '\xEA', '\xEB', '\xEC', '\xED', '\xEE',
+                       '\xEF', '\xF0', '\xF1', '\xF2', '\xF3', '\xF4', '\xF5',
+                       '\xF6', '\xF7', '\xF8', '\xF9', '\xFA'};
+    char C = Lookup[MangledName[0] - 'a'];
+    MangledName = MangledName.dropFront();
+    return C;
+  }
+
+  if (MangledName[0] >= 'A' && MangledName[0] <= 'Z') {
+    char Lookup[26] = {'\xC1', '\xC2', '\xC3', '\xC4', '\xC5', '\xC6', '\xC7',
+                       '\xC8', '\xC9', '\xCA', '\xCB', '\xCC', '\xCD', '\xCE',
+                       '\xCF', '\xD0', '\xD1', '\xD2', '\xD3', '\xD4', '\xD5',
+                       '\xD6', '\xD7', '\xD8', '\xD9', '\xDA'};
+    char C = Lookup[MangledName[0] - 'A'];
+    MangledName = MangledName.dropFront();
+    return C;
+  }
+
+CharLiteralError:
+  Error = true;
+  return '\0';
+}
+
+wchar_t Demangler::demangleWcharLiteral(StringView &MangledName) {
+  uint8_t C1 = demangleCharLiteral(MangledName);
+  if (Error)
+    goto WCharLiteralError;
+  uint8_t C2 = demangleCharLiteral(MangledName);
+  if (Error)
+    goto WCharLiteralError;
+
+  return ((wchar_t)C1 << 8) | (wchar_t)C2;
+
+WCharLiteralError:
+  Error = true;
+  return L'\0';
+}
+
+static void writeHexDigit(char *Buffer, uint8_t Digit) {
+  assert(Digit <= 15);
+  *Buffer = (Digit < 10) ? ('0' + Digit) : ('A' + Digit - 10);
+}
+
+static void outputHex(OutputStream &OS, unsigned C) {
+  if (C == 0) {
+    OS << "\\x00";
+    return;
+  }
+  // It's easier to do the math if we can work from right to left, but we need
+  // to print the numbers from left to right.  So render this into a temporary
+  // buffer first, then output the temporary buffer.  Each byte is of the form
+  // \xAB, which means that each byte needs 4 characters.  Since there are at
+  // most 4 bytes, we need a 4*4+1 = 17 character temporary buffer.
+  char TempBuffer[17];
+
+  ::memset(TempBuffer, 0, sizeof(TempBuffer));
+  constexpr int MaxPos = 15;
+
+  int Pos = MaxPos - 1;
+  while (C != 0) {
+    for (int I = 0; I < 2; ++I) {
+      writeHexDigit(&TempBuffer[Pos--], C % 16);
+      C /= 16;
+    }
+    TempBuffer[Pos--] = 'x';
+    TempBuffer[Pos--] = '\\';
+    assert(Pos >= 0);
+  }
+  OS << StringView(&TempBuffer[Pos + 1]);
+}
+
+static void outputEscapedChar(OutputStream &OS, unsigned C) {
+  switch (C) {
+  case '\'': // single quote
+    OS << "\\\'";
+    return;
+  case '\"': // double quote
+    OS << "\\\"";
+    return;
+  case '\\': // backslash
+    OS << "\\\\";
+    return;
+  case '\a': // bell
+    OS << "\\a";
+    return;
+  case '\b': // backspace
+    OS << "\\b";
+    return;
+  case '\f': // form feed
+    OS << "\\f";
+    return;
+  case '\n': // new line
+    OS << "\\n";
+    return;
+  case '\r': // carriage return
+    OS << "\\r";
+    return;
+  case '\t': // tab
+    OS << "\\t";
+    return;
+  case '\v': // vertical tab
+    OS << "\\v";
+    return;
+  default:
+    break;
+  }
+
+  if (C > 0x1F && C < 0x7F) {
+    // Standard ascii char.
+    OS << (char)C;
+    return;
+  }
+
+  outputHex(OS, C);
+}
+
+unsigned countTrailingNullBytes(const uint8_t *StringBytes, int Length) {
+  const uint8_t *End = StringBytes + Length - 1;
+  while (Length > 0 && *End == 0) {
+    --Length;
+    --End;
+  }
+  return End - StringBytes + 1;
+}
+
+unsigned countEmbeddedNulls(const uint8_t *StringBytes, unsigned Length) {
+  unsigned Result = 0;
+  for (unsigned I = 0; I < Length; ++I) {
+    if (*StringBytes++ == 0)
+      ++Result;
+  }
+  return Result;
+}
+
+unsigned guessCharByteSize(const uint8_t *StringBytes, unsigned NumChars,
+                           unsigned NumBytes) {
+  assert(NumBytes > 0);
+
+  // If the number of bytes is odd, this is guaranteed to be a char string.
+  if (NumBytes % 2 == 1)
+    return 1;
+
+  // All strings can encode at most 32 bytes of data.  If it's less than that,
+  // then we encoded the entire string.  In this case we check for a 1-byte,
+  // 2-byte, or 4-byte null terminator.
+  if (NumBytes < 32) {
+    unsigned TrailingNulls = countTrailingNullBytes(StringBytes, NumChars);
+    if (TrailingNulls >= 4)
+      return 4;
+    if (TrailingNulls >= 2)
+      return 2;
+    return 1;
+  }
+
+  // The whole string was not able to be encoded.  Try to look at embedded null
+  // terminators to guess.  The heuristic is that we count all embedded null
+  // terminators.  If more than 2/3 are null, it's a char32.  If more than 1/3
+  // are null, it's a char16.  Otherwise it's a char8.  This obviously isn't
+  // perfect and is biased towards languages that have ascii alphabets, but this
+  // was always going to be best effort since the encoding is lossy.
+  unsigned Nulls = countEmbeddedNulls(StringBytes, NumChars);
+  if (Nulls >= 2 * NumChars / 3)
+    return 4;
+  if (Nulls >= NumChars / 3)
+    return 2;
+  return 1;
+}
+
+static unsigned decodeMultiByteChar(const uint8_t *StringBytes,
+                                    unsigned CharIndex, unsigned CharBytes) {
+  assert(CharBytes == 1 || CharBytes == 2 || CharBytes == 4);
+  unsigned Offset = CharIndex * CharBytes;
+  unsigned Result = 0;
+  StringBytes = StringBytes + Offset;
+  for (unsigned I = 0; I < CharBytes; ++I) {
+    unsigned C = static_cast<unsigned>(StringBytes[I]);
+    Result |= C << (8 * I);
+  }
+  return Result;
+}
+
+Name *Demangler::demangleStringLiteral(StringView &MangledName) {
+  OutputStream OS;
+  StringView CRC;
+  Name *Result = Arena.alloc<Name>();
+  Result->IsStringLiteral = true;
+
+  // Prefix indicating the beginning of a string literal
+  if (MangledName.empty())
+    goto StringLiteralError;
+
+  // Char Type (regular or wchar_t)
+  bool IsWcharT = false;
+  switch (MangledName.popFront()) {
+  case '1':
+    IsWcharT = true;
+    LLVM_FALLTHROUGH;
+  case '0':
+    break;
+  default:
+    goto StringLiteralError;
+  }
+
+  // Encoded Length
+  uint64_t StringByteSize;
+  bool IsNegative;
+  std::tie(StringByteSize, IsNegative) = demangleNumber(MangledName);
+  if (Error || IsNegative)
+    goto StringLiteralError;
+
+  // CRC 32 (always 8 characters plus a terminator)
+  size_t CrcEndPos = MangledName.find('@');
+  if (CrcEndPos == StringView::npos)
+    goto StringLiteralError;
+  CRC = MangledName.substr(0, CrcEndPos);
+  MangledName = MangledName.dropFront(CrcEndPos + 1);
+  if (MangledName.empty())
+    goto StringLiteralError;
+
+  OS = OutputStream::create(nullptr, nullptr, 1024);
+  if (IsWcharT) {
+    Result->StringLiteralType = PrimTy::Wchar;
+    if (StringByteSize > 64)
+      Result->IsLongStringLiteral = true;
+
+    while (!MangledName.consumeFront('@')) {
+      assert(StringByteSize >= 2);
+      wchar_t W = demangleWcharLiteral(MangledName);
+      if (StringByteSize != 2 || Result->IsLongStringLiteral)
+        outputEscapedChar(OS, W);
+      StringByteSize -= 2;
+      if (Error)
+        goto StringLiteralError;
+    }
+  } else {
+    if (StringByteSize > 32)
+      Result->IsLongStringLiteral = true;
+
+    constexpr unsigned MaxStringByteLength = 32;
+    uint8_t StringBytes[MaxStringByteLength];
+
+    unsigned BytesDecoded = 0;
+    while (!MangledName.consumeFront('@')) {
+      assert(StringByteSize >= 1);
+      StringBytes[BytesDecoded++] = demangleCharLiteral(MangledName);
+    }
+
+    unsigned CharBytes =
+        guessCharByteSize(StringBytes, BytesDecoded, StringByteSize);
+    assert(StringByteSize % CharBytes == 0);
+    switch (CharBytes) {
+    case 1:
+      Result->StringLiteralType = PrimTy::Char;
+      break;
+    case 2:
+      Result->StringLiteralType = PrimTy::Char16;
+      break;
+    case 4:
+      Result->StringLiteralType = PrimTy::Char32;
+      break;
+    default:
+      LLVM_BUILTIN_UNREACHABLE;
+    }
+    const unsigned NumChars = BytesDecoded / CharBytes;
+    for (unsigned CharIndex = 0; CharIndex < NumChars; ++CharIndex) {
+      unsigned NextChar =
+          decodeMultiByteChar(StringBytes, CharIndex, CharBytes);
+      if (CharIndex + 1 < NumChars || Result->IsLongStringLiteral)
+        outputEscapedChar(OS, NextChar);
+    }
+  }
+
+  OS << '\0';
+  char *ResultBuffer = OS.getBuffer();
+  Result->Str = copyString(ResultBuffer);
+  return Result;
+
+StringLiteralError:
+  Error = true;
+  return nullptr;
+}
+
 StringView Demangler::demangleSimpleString(StringView &MangledName,
                                            bool Memorize) {
   StringView S;
   for (size_t i = 0; i < MangledName.size(); ++i) {
     if (MangledName[i] != '@')
       continue;
     S = MangledName.substr(0, i);
     MangledName = MangledName.dropFront(i + 1);
StringView Demangler::resolve(StringView N) {
   return Backrefs.Names[Digit];
 }
 
 void Demangler::output(const Symbol *S, OutputStream &OS) {
   if (S->Category == SymbolCategory::Unknown) {
     outputName(OS, S->SymbolName, S->SymbolType, *this);
     return;
   }
+  if (S->Category == SymbolCategory::StringLiteral) {
+    outputStringLiteral(OS, *S->SymbolName);
+    return;
+  }
+
   // Converts an AST to a string.
   //
   // Converting an AST representing a C++ type to a string is tricky due
   // to the bad grammar of the C++ declaration inherited from C. You have
   // to construct a string from inside to outside. For example, if a type
   // X is a pointer to a function returning int, the order you create a
   // string becomes something like this:
   //

llvm/trunk/test/Demangle/ms-string-literals.test

+; RUN: llvm-undname < %s | FileCheck %s
+
+; CHECK-NOT: Invalid mangled name
+
+??_C@_01CNACBAHC@?$PP?$AA@
+??_C@_01DEBJCBDD@?$PO?$AA@
+??_C@_01BPDEHCPA@?$PN?$AA@
+??_C@_01GCPEDLB@?$PM?$AA@
+??_C@_01EJGONFHG@?$PL?$AA@
+??_C@_01FAHFOEDH@?z?$AA@
+??_C@_01HLFILHPE@?y?$AA@
+??_C@_01GCEDIGLF@?x?$AA@
+??_C@_01OFNLJKHK@?w?$AA@
+??_C@_01PMMAKLDL@?v?$AA@
+??_C@_01NHONPIPI@?u?$AA@
+??_C@_01MOPGMJLJ@?t?$AA@
+??_C@_01IBLHFPHO@?s?$AA@
+??_C@_01JIKMGODP@?r?$AA@
+??_C@_01LDIBDNPM@?q?$AA@
+??_C@_01KKJKAMLN@?p?$AA@
+??_C@_01GHMAACCD@?o?$AA@
+??_C@_01HONLDDGC@?n?$AA@
+??_C@_01FFPGGAKB@?m?$AA@
+??_C@_01EMONFBOA@?l?$AA@
+??_C@_01DKMMHCH@?k?$AA@
+??_C@_01BKLHPGGG@?j?$AA@
+??_C@_01DBJKKFKF@?i?$AA@
+??_C@_01CIIBJEOE@?h?$AA@
+??_C@_01KPBJIICL@?g?$AA@
+??_C@_01LGACLJGK@?f?$AA@
+??_C@_01JNCPOKKJ@?e?$AA@
+??_C@_01IEDENLOI@?d?$AA@
+??_C@_01MLHFENCP@?c?$AA@
+??_C@_01NCGOHMGO@?b?$AA@
+??_C@_01PJEDCPKN@?a?$AA@
+??_C@_01OAFIBOOM@?$OA?$AA@
+??_C@_01LIIGDENA@?$NP?$AA@
+??_C@_01KBJNAFJB@?$NO?$AA@
+??_C@_01IKLAFGFC@?$NN?$AA@
+??_C@_01JDKLGHBD@?$NM?$AA@
+??_C@_01NMOKPBNE@?$NL?$AA@
+??_C@_01MFPBMAJF@?Z?$AA@
+??_C@_01OONMJDFG@?Y?$AA@
+??_C@_01PHMHKCBH@?X?$AA@
+??_C@_01HAFPLONI@?W?$AA@
+??_C@_01GJEEIPJJ@?V?$AA@
+??_C@_01ECGJNMFK@?U?$AA@
+??_C@_01FLHCONBL@?T?$AA@
+??_C@_01BEDDHLNM@?S?$AA@
+??_C@_01NCIEKJN@?R?$AA@
+??_C@_01CGAFBJFO@?Q?$AA@
+??_C@_01DPBOCIBP@?P?$AA@
+??_C@_01PCEECGIB@?O?$AA@
+??_C@_01OLFPBHMA@?N?$AA@
+??_C@_01MAHCEEAD@?M?$AA@
+??_C@_01NJGJHFEC@?L?$AA@
+??_C@_01JGCIODIF@?K?$AA@
+??_C@_01IPDDNCME@?J?$AA@
+??_C@_01KEBOIBAH@?I?$AA@
+??_C@_01LNAFLAEG@?H?$AA@
+??_C@_01DKJNKMIJ@?G?$AA@
+??_C@_01CDIGJNMI@?F?$AA@
+??_C@_01IKLMOAL@?E?$AA@
+??_C@_01BBLAPPEK@?D?$AA@
+??_C@_01FOPBGJIN@?C?$AA@
+??_C@_01EHOKFIMM@?B?$AA@
+??_C@_01GMMHALAP@?A?$AA@
+??_C@_01HFNMDKEO@?$MA?$AA@
+??_C@_01NNHLFPHH@?$LP?$AA@
+??_C@_01MEGAGODG@?$LO?$AA@
+??_C@_01OPENDNPF@?$LN?$AA@
+??_C@_01PGFGAMLE@?$LM?$AA@
+??_C@_01LJBHJKHD@?$LL?$AA@
+??_C@_01KAAMKLDC@?$LK?$AA@
+??_C@_01ILCBPIPB@?$LJ?$AA@
+??_C@_01JCDKMJLA@?$LI?$AA@
+??_C@_01BFKCNFHP@?$LH?$AA@
+??_C@_01MLJOEDO@?$LG?$AA@
+??_C@_01CHJELHPN@?$LF?$AA@
+??_C@_01DOIPIGLM@?$LE?$AA@
+??_C@_01HBMOBAHL@?$LD?$AA@
+??_C@_01GINFCBDK@?$LC?$AA@
+??_C@_01EDPIHCPJ@?$LB?$AA@
+??_C@_01FKODEDLI@?$LA?$AA@
+??_C@_01JHLJENCG@?$KP?$AA@
+??_C@_01IOKCHMGH@?$KO?$AA@
+??_C@_01KFIPCPKE@?$KN?$AA@
+??_C@_01LMJEBOOF@?$KM?$AA@
+??_C@_01PDNFIICC@?$KL?$AA@
+??_C@_01OKMOLJGD@?$KK?$AA@
+??_C@_01MBODOKKA@?$KJ?$AA@
+??_C@_01NIPINLOB@?$KI?$AA@
+??_C@_01FPGAMHCO@?$KH?$AA@
+??_C@_01EGHLPGGP@?$KG?$AA@
+??_C@_01GNFGKFKM@?$KF?$AA@
+??_C@_01HEENJEON@?$KE?$AA@
+??_C@_01DLAMACCK@?$KD?$AA@
+??_C@_01CCBHDDGL@?$KC?$AA@
+??_C@_01JDKGAKI@?$KB?$AA@
+??_C@_01BACBFBOJ@?$KA?$AA@
+??_C@_01EIPPHLNF@?$JP?$AA@
+??_C@_01FBOEEKJE@?$JO?$AA@
+??_C@_01HKMJBJFH@?$JN?$AA@
+??_C@_01GDNCCIBG@?$JM?$AA@
+??_C@_01CMJDLONB@?$JL?$AA@
+??_C@_01DFIIIPJA@?$JK?$AA@
+??_C@_01BOKFNMFD@?$JJ?$AA@
+??_C@_01HLOONBC@?$JI?$AA@
+??_C@_01IACGPBNN@?$JH?$AA@
+??_C@_01JJDNMAJM@?$JG?$AA@
+??_C@_01LCBAJDFP@?$JF?$AA@
+??_C@_01KLALKCBO@?$JE?$AA@
+??_C@_01OEEKDENJ@?$JD?$AA@
+??_C@_01PNFBAFJI@?$JC?$AA@
+??_C@_01NGHMFGFL@?$JB?$AA@
+??_C@_01MPGHGHBK@?$JA?$AA@
+??_C@_01CDNGJIE@?$IP?$AA@
+??_C@_01BLCGFIMF@?$IO?$AA@
+??_C@_01DAALALAG@?$IN?$AA@
+??_C@_01CJBADKEH@?$IM?$AA@
+??_C@_01GGFBKMIA@?$IL?$AA@
+??_C@_01HPEKJNMB@?$IK?$AA@
+??_C@_01FEGHMOAC@?$IJ?$AA@
+??_C@_01ENHMPPED@?$II?$AA@
+??_C@_01MKOEODIM@?$IH?$AA@
+??_C@_01NDPPNCMN@?$IG?$AA@
+??_C@_01PINCIBAO@?$IF?$AA@
+??_C@_01OBMJLAEP@?$IE?$AA@
+??_C@_01KOIICGII@?$ID?$AA@
+??_C@_01LHJDBHMJ@?$IC?$AA@
+??_C@_01JMLOEEAK@?$IB?$AA@
+??_C@_01IFKFHFEL@?$IA?$AA@
+??_C@_01BGIBIIDJ@?$HP?$AA@
+??_C@_01PJKLJHI@?$HO?$AA@
+??_C@_01CELHOKLL@?$HN?$AA@
+??_C@_01DNKMNLPK@?$HM?$AA@
+??_C@_01HCONENDN@?$HL?$AA@
+??_C@_01GLPGHMHM@z?$AA@
+??_C@_01EANLCPLP@y?$AA@
+??_C@_01FJMABOPO@x?$AA@
+??_C@_01NOFIACDB@w?$AA@
+??_C@_01MHEDDDHA@v?$AA@
+??_C@_01OMGOGALD@u?$AA@
+??_C@_01PFHFFBPC@t?$AA@
+??_C@_01LKDEMHDF@s?$AA@
+??_C@_01KDCPPGHE@r?$AA@
+??_C@_01IIACKFLH@q?$AA@
+??_C@_01JBBJJEPG@p?$AA@
+??_C@_01FMEDJKGI@o?$AA@
+??_C@_01EFFIKLCJ@n?$AA@
+??_C@_01GOHFPIOK@m?$AA@
+??_C@_01HHGOMJKL@l?$AA@
+??_C@_01DICPFPGM@k?$AA@
+??_C@_01CBDEGOCN@j?$AA@
+??_C@_01KBJDNOO@i?$AA@
+??_C@_01BDACAMKP@h?$AA@
+??_C@_01JEJKBAGA@g?$AA@
+??_C@_01INIBCBCB@f?$AA@
+??_C@_01KGKMHCOC@e?$AA@
+??_C@_01LPLHEDKD@d?$AA@
+??_C@_01PAPGNFGE@c?$AA@
+??_C@_01OJONOECF@b?$AA@
+??_C@_01MCMALHOG@a?$AA@
+??_C@_01NLNLIGKH@?$GA?$AA@
+??_C@_01IDAFKMJL@_?$AA@
+??_C@_01JKBOJNNK@?$FO?$AA@
+??_C@_01LBDDMOBJ@?$FN?$AA@
+??_C@_01KICIPPFI@?2?$AA@
+??_C@_01OHGJGJJP@?$FL?$AA@
+??_C@_01POHCFINO@Z?$AA@
+??_C@_01NFFPALBN@Y?$AA@
+??_C@_01MMEEDKFM@X?$AA@
+??_C@_01ELNMCGJD@W?$AA@
+??_C@_01FCMHBHNC@V?$AA@
+??_C@_01HJOKEEBB@U?$AA@
+??_C@_01GAPBHFFA@T?$AA@
+??_C@_01CPLAODJH@S?$AA@
+??_C@_01DGKLNCNG@R?$AA@
+??_C@_01BNIGIBBF@Q?$AA@
+??_C@_01EJNLAFE@P?$AA@
+??_C@_01MJMHLOMK@O?$AA@
+??_C@_01NANMIPIL@N?$AA@
+??_C@_01PLPBNMEI@M?$AA@
+??_C@_01OCOKONAJ@L?$AA@
+??_C@_01KNKLHLMO@K?$AA@
+??_C@_01LELAEKIP@J?$AA@
+??_C@_01JPJNBJEM@I?$AA@
+??_C@_01IGIGCIAN@H?$AA@
+??_C@_01BBODEMC@G?$AA@
+??_C@_01BIAFAFID@F?$AA@
+??_C@_01DDCIFGEA@E?$AA@
+??_C@_01CKDDGHAB@D?$AA@
+??_C@_01GFHCPBMG@C?$AA@
+??_C@_01HMGJMAIH@B?$AA@
+??_C@_01FHEEJDEE@A?$AA@
+??_C@_01EOFPKCAF@?$EA?$AA@
+??_C@_01OGPIMHDM@?$DP?$AA@
+??_C@_01PPODPGHN@?$DO?$AA@
+??_C@_01NEMOKFLO@?$DN?$AA@
+??_C@_01MNNFJEPP@?$DM?$AA@
+??_C@_01ICJEACDI@?$DL?$AA@
+??_C@_01JLIPDDHJ@?3?$AA@
+??_C@_01LAKCGALK@9?$AA@
+??_C@_01KJLJFBPL@8?$AA@
+??_C@_01COCBENDE@7?$AA@
+??_C@_01DHDKHMHF@6?$AA@
+??_C@_01BMBHCPLG@5?$AA@
+??_C@_01FAMBOPH@4?$AA@
+??_C@_01EKENIIDA@3?$AA@
+??_C@_01FDFGLJHB@2?$AA@
+??_C@_01HIHLOKLC@1?$AA@
+??_C@_01GBGANLPD@0?$AA@
+??_C@_01KMDKNFGN@?1?$AA@
+??_C@_01LFCBOECM@?4?$AA@
+??_C@_01JOAMLHOP@?9?$AA@
+??_C@_01IHBHIGKO@?0?$AA@
+??_C@_01MIFGBAGJ@?$CL?$AA@
+??_C@_01NBENCBCI@?$CK?$AA@
+??_C@_01PKGAHCOL@?$CJ?$AA@
+??_C@_01ODHLEDKK@?$CI?$AA@
+??_C@_01GEODFPGF@?8?$AA@
+??_C@_01HNPIGOCE@?$CG?$AA@
+??_C@_01FGNFDNOH@?$CF?$AA@
+??_C@_01EPMOAMKG@$?$AA@
+??_C@_01IPJKGB@?$CD?$AA@
+??_C@_01BJJEKLCA@?$CC?$AA@
+??_C@_01DCLJPIOD@?$CB?$AA@
+??_C@_01CLKCMJKC@?5?$AA@
+??_C@_01HDHMODJO@?$BP?$AA@
+??_C@_01GKGHNCNP@?$BO?$AA@
+??_C@_01EBEKIBBM@?$BN?$AA@
+??_C@_01FIFBLAFN@?$BM?$AA@
+??_C@_01BHBACGJK@?$BL?$AA@
+??_C@_01OALBHNL@?$BK?$AA@
+??_C@_01CFCGEEBI@?$BJ?$AA@
+??_C@_01DMDNHFFJ@?$BI?$AA@
+??_C@_01LLKFGJJG@?$BH?$AA@
+??_C@_01KCLOFINH@?$BG?$AA@
+??_C@_01IJJDALBE@?$BF?$AA@
+??_C@_01JAIIDKFF@?$BE?$AA@
+??_C@_01NPMJKMJC@?$BD?$AA@
+??_C@_01MGNCJNND@?$BC?$AA@
+??_C@_01ONPPMOBA@?$BB?$AA@
+??_C@_01PEOEPPFB@?$BA?$AA@
+??_C@_01DJLOPBMP@?$AP?$AA@
+??_C@_01CAKFMAIO@?$AO?$AA@
+??_C@_01LIIJDEN@?$AN?$AA@
+??_C@_01BCJDKCAM@?$AM?$AA@
+??_C@_01FNNCDEML@?$AL?$AA@
+??_C@_01EEMJAFIK@?6?$AA@
+??_C@_01GPOEFGEJ@?7?$AA@
+??_C@_01HGPPGHAI@?$AI?$AA@
+??_C@_01PBGHHLMH@?$AH?$AA@
+??_C@_01OIHMEKIG@?$AG?$AA@
+??_C@_01MDFBBJEF@?$AF?$AA@
+??_C@_01NKEKCIAE@?$AE?$AA@
+??_C@_01JFALLOMD@?$AD?$AA@
+??_C@_01IMBAIPIC@?$AC?$AA@
+??_C@_01KHDNNMEB@?$AB?$AA@
+??_C@_01LOCGONAA@?$AA?$AA@
+
+; CHECK: const char * {"\xFF"}
+; CHECK: const char * {"\xFE"}
+; CHECK: const char * {"\xFD"}
+; CHECK: const char * {"\xFC"}
+; CHECK: const char * {"\xFB"}
+; CHECK: const char * {"\xFA"}
+; CHECK: const char * {"\xF9"}
+; CHECK: const char * {"\xF8"}
+; CHECK: const char * {"\xF7"}
+; CHECK: const char * {"\xF6"}
+; CHECK: const char * {"\xF5"}
+; CHECK: const char * {"\xF4"}
+; CHECK: const char * {"\xF3"}
+; CHECK: const char * {"\xF2"}
+; CHECK: const char * {"\xF1"}
+; CHECK: const char * {"\xF0"}
+; CHECK: const char * {"\xEF"}
+; CHECK: const char * {"\xEE"}
+; CHECK: const char * {"\xED"}
+; CHECK: const char * {"\xEC"}
+; CHECK: const char * {"\xEB"}
+; CHECK: const char * {"\xEA"}
+; CHECK: const char * {"\xE9"}
+; CHECK: const char * {"\xE8"}
+; CHECK: const char * {"\xE7"}
+; CHECK: const char * {"\xE6"}
+; CHECK: const char * {"\xE5"}
+; CHECK: const char * {"\xE4"}
+; CHECK: const char * {"\xE3"}
+; CHECK: const char * {"\xE2"}
+; CHECK: const char * {"\xE1"}
+; CHECK: const char * {"\xE0"}
+; CHECK: const char * {"\xDF"}
+; CHECK: const char * {"\xDE"}
+; CHECK: const char * {"\xDD"}
+; CHECK: const char * {"\xDC"}
+; CHECK: const char * {"\xDB"}
+; CHECK: const char * {"\xDA"}
+; CHECK: const char * {"\xD9"}
+; CHECK: const char * {"\xD8"}
+; CHECK: const char * {"\xD7"}
+; CHECK: const char * {"\xD6"}
+; CHECK: const char * {"\xD5"}
+; CHECK: const char * {"\xD4"}
+; CHECK: const char * {"\xD3"}
+; CHECK: const char * {"\xD2"}
+; CHECK: const char * {"\xD1"}
+; CHECK: const char * {"\xD0"}
+; CHECK: const char * {"\xCF"}
+; CHECK: const char * {"\xCE"}
+; CHECK: const char * {"\xCD"}
+; CHECK: const char * {"\xCC"}
+; CHECK: const char * {"\xCB"}
+; CHECK: const char * {"\xCA"}
+; CHECK: const char * {"\xC9"}
+; CHECK: const char * {"\xC8"}
+; CHECK: const char * {"\xC7"}
+; CHECK: const char * {"\xC6"}
+; CHECK: const char * {"\xC5"}
+; CHECK: const char * {"\xC4"}
+; CHECK: const char * {"\xC3"}
+; CHECK: const char * {"\xC2"}
+; CHECK: const char * {"\xC1"}
+; CHECK: const char * {"\xC0"}
+; CHECK: const char * {"\xBF"}
+; CHECK: const char * {"\xBE"}
+; CHECK: const char * {"\xBD"}
+; CHECK: const char * {"\xBC"}
+; CHECK: const char * {"\xBB"}
+; CHECK: const char * {"\xBA"}
+; CHECK: const char * {"\xB9"}
+; CHECK: const char * {"\xB8"}
+; CHECK: const char * {"\xB7"}
+; CHECK: const char * {"\xB6"}
+; CHECK: const char * {"\xB5"}
+; CHECK: const char * {"\xB4"}
+; CHECK: const char * {"\xB3"}
+; CHECK: const char * {"\xB2"}
+; CHECK: const char * {"\xB1"}
+; CHECK: const char * {"\xB0"}
+; CHECK: const char * {"\xAF"}
+; CHECK: const char * {"\xAE"}
+; CHECK: const char * {"\xAD"}
+; CHECK: const char * {"\xAC"}
+; CHECK: const char * {"\xAB"}
+; CHECK: const char * {"\xAA"}
+; CHECK: const char * {"\xA9"}
+; CHECK: const char * {"\xA8"}
+; CHECK: const char * {"\xA7"}
+; CHECK: const char * {"\xA6"}
+; CHECK: const char * {"\xA5"}
+; CHECK: const char * {"\xA4"}
+; CHECK: const char * {"\xA3"}
+; CHECK: const char * {"\xA2"}
+; CHECK: const char * {"\xA1"}
+; CHECK: const char * {"\xA0"}
+; CHECK: const char * {"\x9F"}
+; CHECK: const char * {"\x9E"}
+; CHECK: const char * {"\x9D"}
+; CHECK: const char * {"\x9C"}
+; CHECK: const char * {"\x9B"}
+; CHECK: const char * {"\x9A"}
+; CHECK: const char * {"\x99"}
+; CHECK: const char * {"\x98"}
+; CHECK: const char * {"\x97"}
+; CHECK: const char * {"\x96"}
+; CHECK: const char * {"\x95"}
+; CHECK: const char * {"\x94"}
+; CHECK: const char * {"\x93"}
+; CHECK: const char * {"\x92"}
+; CHECK: const char * {"\x91"}
+; CHECK: const char * {"\x90"}
+; CHECK: const char * {"\x8F"}
+; CHECK: const char * {"\x8E"}
+; CHECK: const char * {"\x8D"}
+; CHECK: const char * {"\x8C"}
+; CHECK: const char * {"\x8B"}
+; CHECK: const char * {"\x8A"}
+; CHECK: const char * {"\x89"}
+; CHECK: const char * {"\x88"}
+; CHECK: const char * {"\x87"}
+; CHECK: const char * {"\x86"}
+; CHECK: const char * {"\x85"}
+; CHECK: const char * {"\x84"}
+; CHECK: const char * {"\x83"}
+; CHECK: const char * {"\x82"}
+; CHECK: const char * {"\x81"}
+; CHECK: const char * {"\x80"}
+; CHECK: const char * {"\x7F"}
+; CHECK: const char * {"~"}
+; CHECK: const char * {"}"}
+; CHECK: const char * {"|"}
+; CHECK: const char * {"{"}
+; CHECK: const char * {"z"}
+; CHECK: const char * {"y"}
+; CHECK: const char * {"x"}
+; CHECK: const char * {"w"}
+; CHECK: const char * {"v"}
+; CHECK: const char * {"u"}
+; CHECK: const char * {"t"}
+; CHECK: const char * {"s"}
+; CHECK: const char * {"r"}
+; CHECK: const char * {"q"}
+; CHECK: const char * {"p"}
+; CHECK: const char * {"o"}
+; CHECK: const char * {"n"}
+; CHECK: const char * {"m"}
+; CHECK: const char * {"l"}
+; CHECK: const char * {"k"}
+; CHECK: const char * {"j"}
+; CHECK: const char * {"i"}
+; CHECK: const char * {"h"}
+; CHECK: const char * {"g"}
+; CHECK: const char * {"f"}
+; CHECK: const char * {"e"}
+; CHECK: const char * {"d"}
+; CHECK: const char * {"c"}
+; CHECK: const char * {"b"}
+; CHECK: const char * {"a"}
+; CHECK: const char * {"`"}
+; CHECK: const char * {"_"}
+; CHECK: const char * {"^"}
+; CHECK: const char * {"]"}
+; CHECK: const char * {"\\"}
+; CHECK: const char * {"["}
+; CHECK: const char * {"Z"}
+; CHECK: const char * {"Y"}
+; CHECK: const char * {"X"}
+; CHECK: const char * {"W"}
+; CHECK: const char * {"V"}
+; CHECK: const char * {"U"}
+; CHECK: const char * {"T"}
+; CHECK: const char * {"S"}
+; CHECK: const char * {"R"}
+; CHECK: const char * {"Q"}
+; CHECK: const char * {"P"}
+; CHECK: const char * {"O"}
+; CHECK: const char * {"N"}
+; CHECK: const char * {"M"}
+; CHECK: const char * {"L"}
+; CHECK: const char * {"K"}
+; CHECK: const char * {"J"}
+; CHECK: const char * {"I"}
+; CHECK: const char * {"H"}
+; CHECK: const char * {"G"}
+; CHECK: const char * {"F"}
+; CHECK: const char * {"E"}
+; CHECK: const char * {"D"}
+; CHECK: const char * {"C"}
+; CHECK: const char * {"B"}
+; CHECK: const char * {"A"}
+; CHECK: const char * {"@"}
+; CHECK: const char * {"?"}
+; CHECK: const char * {">"}
+; CHECK: const char * {"="}
+; CHECK: const char * {"<"}
+; CHECK: const char * {";"}
+; CHECK: const char * {":"}
+; CHECK: const char * {"9"}
+; CHECK: const char * {"8"}
+; CHECK: const char * {"7"}
+; CHECK: const char * {"6"}
+; CHECK: const char * {"5"}
+; CHECK: const char * {"4"}
+; CHECK: const char * {"3"}
+; CHECK: const char * {"2"}
+; CHECK: const char * {"1"}
+; CHECK: const char * {"0"}
+; CHECK: const char * {"/"}
+; CHECK: const char * {"."}
+; CHECK: const char * {"-"}
+; CHECK: const char * {","}
+; CHECK: const char * {"+"}
+; CHECK: const char * {"*"}
+; CHECK: const char * {")"}
+; CHECK: const char * {"("}
+; CHECK: const char * {"\'"}
+; CHECK: const char * {"&"}
+; CHECK: const char * {"%"}
+; CHECK: const char * {"$"}
+; CHECK: const char * {"#"}
+; CHECK: const char * {"\""}
+; CHECK: const char * {"!"}
+; CHECK: const char * {" "}
+; CHECK: const char * {"\x1F"}
+; CHECK: const char * {"\x1E"}
+; CHECK: const char * {"\x1D"}
+; CHECK: const char * {"\x1C"}
+; CHECK: const char * {"\x1B"}
+; CHECK: const char * {"\x1A"}
+; CHECK: const char * {"\x19"}
+; CHECK: const char * {"\x18"}
+; CHECK: const char * {"\x17"}
+; CHECK: const char * {"\x16"}
+; CHECK: const char * {"\x15"}
+; CHECK: const char * {"\x14"}
+; CHECK: const char * {"\x13"}
+; CHECK: const char * {"\x12"}
+; CHECK: const char * {"\x11"}
+; CHECK: const char * {"\x10"}
+; CHECK: const char * {"\x0F"}
+; CHECK: const char * {"\x0E"}
+; CHECK: const char * {"\r"}
+; CHECK: const char * {"\f"}
+; CHECK: const char * {"\v"}
+; CHECK: const char * {"\n"}
+; CHECK: const char * {"\t"}
+; CHECK: const char * {"\b"}
+; CHECK: const char * {"\a"}
+; CHECK: const char * {"\x06"}
+; CHECK: const char * {"\x05"}
+; CHECK: const char * {"\x04"}
+; CHECK: const char * {"\x03"}
+; CHECK: const char * {"\x02"}
+; CHECK: const char * {"\x01"}
+; CHECK: const char * {"\x00"}
+
+
+??_C@_13KDLDGPGJ@?$AA?7?$AA?$AA@
+??_C@_13LBAGMAIH@?$AA?6?$AA?$AA@
+??_C@_13JLKKHOC@?$AA?$AL?$AA?$AA@
+??_C@_13HOIJIPNN@?$AA?5?$AA?$AA@
+??_C@_13MGDFOILI@?$AA?$CB?$AA?$AA@
+??_C@_13NEIAEHFG@?$AA?$CC?$AA?$AA@
+??_C@_13GMDMCADD@?$AA?$CD?$AA?$AA@
+??_C@_13PBOLBIIK@?$AA$?$AA?$AA@
+??_C@_13EJFHHPOP@?$AA?$CF?$AA?$AA@
+??_C@_13FLOCNAAB@?$AA?$CG?$AA?$AA@
+??_C@_13ODFOLHGE@?$AA?8?$AA?$AA@
+??_C@_13LLDNKHDC@?$AA?$CI?$AA?$AA@
+??_C@_13DIBMAFH@?$AA?$CJ?$AA?$AA@
+??_C@_13BBDEGPLJ@?$AA?$CK?$AA?$AA@
+??_C@_13KJIIAINM@?$AA?$CL?$AA?$AA@
+??_C@_13DEFPDAGF@?$AA?0?$AA?$AA@
+??_C@_13IMODFHAA@?$AA?9?$AA?$AA@
+??_C@_13JOFGPIOO@?$AA?4?$AA?$AA@
+??_C@_13CGOKJPIL@?$AA?1?$AA?$AA@
+??_C@_13COJANIEC@?$AA0?$AA?$AA@
+??_C@_13JGCMLPCH@?$AA1?$AA?$AA@
+??_C@_13IEJJBAMJ@?$AA2?$AA?$AA@
+??_C@_13DMCFHHKM@?$AA3?$AA?$AA@
+??_C@_13KBPCEPBF@?$AA4?$AA?$AA@
+??_C@_13BJEOCIHA@?$AA5?$AA?$AA@
+??_C@_13LPLIHJO@?$AA6?$AA?$AA@
+??_C@_13LDEHOAPL@?$AA7?$AA?$AA@
+??_C@_13OLCEPAKN@?$AA8?$AA?$AA@
+??_C@_13FDJIJHMI@?$AA9?$AA?$AA@
+??_C@_13EBCNDICG@?$AA?3?$AA?$AA@
+??_C@_13PJJBFPED@?$AA?$DL?$AA?$AA@
+??_C@_13GEEGGHPK@?$AA?$DM?$AA?$AA@
+??_C@_13NMPKAAJP@?$AA?$DN?$AA?$AA@
+??_C@_13MOEPKPHB@?$AA?$DO?$AA?$AA@
+??_C@_13HGPDMIBE@?$AA?$DP?$AA?$AA@
+??_C@_13EFKPHINO@?$AA?$EA?$AA?$AA@
+??_C@_13PNBDBPLL@?$AAA?$AA?$AA@
+??_C@_13OPKGLAFF@?$AAB?$AA?$AA@
+??_C@_13FHBKNHDA@?$AAC?$AA?$AA@
+??_C@_13MKMNOPIJ@?$AAD?$AA?$AA@
+??_C@_13HCHBIIOM@?$AAE?$AA?$AA@
+??_C@_13GAMECHAC@?$AAF?$AA?$AA@
+??_C@_13NIHIEAGH@?$AAG?$AA?$AA@
+??_C@_13IABLFADB@?$AAH?$AA?$AA@
+??_C@_13DIKHDHFE@?$AAI?$AA?$AA@
+??_C@_13CKBCJILK@?$AAJ?$AA?$AA@
+??_C@_13JCKOPPNP@?$AAK?$AA?$AA@
+??_C@_13PHJMHGG@?$AAL?$AA?$AA@
+??_C@_13LHMFKAAD@?$AAM?$AA?$AA@
+??_C@_13KFHAAPON@?$AAN?$AA?$AA@
+??_C@_13BNMMGIII@?$AAO?$AA?$AA@
+??_C@_13BFLGCPEB@?$AAP?$AA?$AA@
+??_C@_13KNAKEICE@?$AAQ?$AA?$AA@
+??_C@_13LPLPOHMK@?$AAR?$AA?$AA@
+??_C@_13HADIAKP@?$AAS?$AA?$AA@
+??_C@_13JKNELIBG@?$AAT?$AA?$AA@
+??_C@_13CCGINPHD@?$AAU?$AA?$AA@
+??_C@_13DANNHAJN@?$AAV?$AA?$AA@
+??_C@_13IIGBBHPI@?$AAW?$AA?$AA@
+??_C@_13NAACAHKO@?$AAX?$AA?$AA@
+??_C@_13GILOGAML@?$AAY?$AA?$AA@
+??_C@_13HKALMPCF@?$AAZ?$AA?$AA@
+??_C@_13MCLHKIEA@?$AA?$FL?$AA?$AA@
+??_C@_13FPGAJAPJ@?$AA?2?$AA?$AA@
+??_C@_13OHNMPHJM@?$AA?$FN?$AA?$AA@
+??_C@_13PFGJFIHC@?$AA?$FO?$AA?$AA@
+??_C@_13ENNFDPBH@?$AA_?$AA?$AA@
+??_C@_13OFJNNHOA@?$AA?$GA?$AA?$AA@
+??_C@_13FNCBLAIF@?$AAa?$AA?$AA@
+??_C@_13EPJEBPGL@?$AAb?$AA?$AA@
+??_C@_13PHCIHIAO@?$AAc?$AA?$AA@
+??_C@_13GKPPEALH@?$AAd?$AA?$AA@
+??_C@_13NCEDCHNC@?$AAe?$AA?$AA@
+??_C@_13MAPGIIDM@?$AAf?$AA?$AA@
+??_C@_13HIEKOPFJ@?$AAg?$AA?$AA@
+??_C@_13CACJPPAP@?$AAh?$AA?$AA@
+??_C@_13JIJFJIGK@?$AAi?$AA?$AA@
+??_C@_13IKCADHIE@?$AAj?$AA?$AA@
+??_C@_13DCJMFAOB@?$AAk?$AA?$AA@
+??_C@_13KPELGIFI@?$AAl?$AA?$AA@
+??_C@_13BHPHAPDN@?$AAm?$AA?$AA@
+??_C@_13FECKAND@?$AAn?$AA?$AA@
+??_C@_13LNPOMHLG@?$AAo?$AA?$AA@
+??_C@_13LFIEIAHP@?$AAp?$AA?$AA@
+??_C@_13NDIOHBK@?$AAq?$AA?$AA@
+??_C@_13BPINEIPE@?$AAr?$AA?$AA@
+??_C@_13KHDBCPJB@?$AAs?$AA?$AA@
+??_C@_13DKOGBHCI@?$AAt?$AA?$AA@
+??_C@_13ICFKHAEN@?$AAu?$AA?$AA@
+??_C@_13JAOPNPKD@?$AAv?$AA?$AA@
+??_C@_13CIFDLIMG@?$AAw?$AA?$AA@
+??_C@_13HADAKIJA@?$AAx?$AA?$AA@
+??_C@_13MIIMMPPF@?$AAy?$AA?$AA@
+??_C@_13NKDJGABL@?$AAz?$AA?$AA@
+??_C@_13GCIFAHHO@?$AA?$HL?$AA?$AA@
+??_C@_13PPFCDPMH@?$AA?$HM?$AA?$AA@
+??_C@_13EHOOFIKC@?$AA?$HN?$AA?$AA@
+??_C@_13FFFLPHEM@?$AA?$HO?$AA?$AA@
+
+; CHECK: const wchar_t * {L"\t"}
+; CHECK: const wchar_t * {L"\n"}
+; CHECK: const wchar_t * {L"\v"}
+; CHECK: const wchar_t * {L" "}
+; CHECK: const wchar_t * {L"!"}
+; CHECK: const wchar_t * {L"\""}
+; CHECK: const wchar_t * {L"#"}
+; CHECK: const wchar_t * {L"$"}
+; CHECK: const wchar_t * {L"%"}
+; CHECK: const wchar_t * {L"&"}
+; CHECK: const wchar_t * {L"\'"}
+; CHECK: const wchar_t * {L"("}
+; CHECK: const wchar_t * {L")"}
+; CHECK: const wchar_t * {L"*"}
+; CHECK: const wchar_t * {L"+"}
+; CHECK: const wchar_t * {L","}
+; CHECK: const wchar_t * {L"-"}
+; CHECK: const wchar_t * {L"."}
+; CHECK: const wchar_t * {L"/"}
+; CHECK: const wchar_t * {L"0"}
+; CHECK: const wchar_t * {L"1"}
+; CHECK: const wchar_t * {L"2"}
+; CHECK: const wchar_t * {L"3"}
+; CHECK: const wchar_t * {L"4"}
+; CHECK: const wchar_t * {L"5"}
+; CHECK: const wchar_t * {L"6"}
+; CHECK: const wchar_t * {L"7"}
+; CHECK: const wchar_t * {L"8"}
+; CHECK: const wchar_t * {L"9"}
+; CHECK: const wchar_t * {L":"}
+; CHECK: const wchar_t * {L";"}
+; CHECK: const wchar_t * {L"<"}
+; CHECK: const wchar_t * {L"="}
+; CHECK: const wchar_t * {L">"}
+; CHECK: const wchar_t * {L"?"}
+; CHECK: const wchar_t * {L"@"}
+; CHECK: const wchar_t * {L"A"}
+; CHECK: const wchar_t * {L"B"}
+; CHECK: const wchar_t * {L"C"}
+; CHECK: const wchar_t * {L"D"}
+; CHECK: const wchar_t * {L"E"}
+; CHECK: const wchar_t * {L"F"}
+; CHECK: const wchar_t * {L"G"}
+; CHECK: const wchar_t * {L"H"}
+; CHECK: const wchar_t * {L"I"}
+; CHECK: const wchar_t * {L"J"}
+; CHECK: const wchar_t * {L"K"}
+; CHECK: const wchar_t * {L"L"}
+; CHECK: const wchar_t * {L"M"}
+; CHECK: const wchar_t * {L"N"}
+; CHECK: const wchar_t * {L"O"}
+; CHECK: const wchar_t * {L"P"}
+; CHECK: const wchar_t * {L"Q"}
+; CHECK: const wchar_t * {L"R"}
+; CHECK: const wchar_t * {L"S"}
+; CHECK: const wchar_t * {L"T"}
+; CHECK: const wchar_t * {L"U"}
+; CHECK: const wchar_t * {L"V"}
+; CHECK: const wchar_t * {L"W"}
+; CHECK: const wchar_t * {L"X"}
+; CHECK: const wchar_t * {L"Y"}
+; CHECK: const wchar_t * {L"Z"}
+; CHECK: const wchar_t * {L"["}
+; CHECK: const wchar_t * {L"\\"}
+; CHECK: const wchar_t * {L"]"}
+; CHECK: const wchar_t * {L"^"}
+; CHECK: const wchar_t * {L"_"}
+; CHECK: const wchar_t * {L"`"}
+; CHECK: const wchar_t * {L"a"}
+; CHECK: const wchar_t * {L"b"}
+; CHECK: const wchar_t * {L"c"}
+; CHECK: const wchar_t * {L"d"}
+; CHECK: const wchar_t * {L"e"}
+; CHECK: const wchar_t * {L"f"}
+; CHECK: const wchar_t * {L"g"}
+; CHECK: const wchar_t * {L"h"}
+; CHECK: const wchar_t * {L"i"}
+; CHECK: const wchar_t * {L"j"}
+; CHECK: const wchar_t * {L"k"}
+; CHECK: const wchar_t * {L"l"}
+; CHECK: const wchar_t * {L"m"}
+; CHECK: const wchar_t * {L"n"}
+; CHECK: const wchar_t * {L"o"}
+; CHECK: const wchar_t * {L"p"}
+; CHECK: const wchar_t * {L"q"}
+; CHECK: const wchar_t * {L"r"}
+; CHECK: const wchar_t * {L"s"}
+; CHECK: const wchar_t * {L"t"}
+; CHECK: const wchar_t * {L"u"}
+; CHECK: const wchar_t * {L"v"}
+; CHECK: const wchar_t * {L"w"}
+; CHECK: const wchar_t * {L"x"}
+; CHECK: const wchar_t * {L"y"}
+; CHECK: const wchar_t * {L"z"}
+; CHECK: const wchar_t * {L"{"}
+; CHECK: const wchar_t * {L"|"}
+; CHECK: const wchar_t * {L"}"}
+; CHECK: const wchar_t * {L"~"}
+
+
+
+??_C@_0CF@LABBIIMO@012345678901234567890123456789AB@
+; CHECK: const char * {"012345678901234567890123456789AB"...}
+
+??_C@_1EK@KFPEBLPK@?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AAA?$AAB@
+; CHECK: const wchar_t * {L"012345678901234567890123456789AB"...}
+
+??_C@_13IIHIAFKH@?W?$PP?$AA?$AA@
+; CHECK: const wchar_t * {L"\xD7\xFF"}
+
+??_C@_02PCEFGMJL@hi?$AA@
+; CHECK: const char * {"hi"}
+
+??_C@_05OMLEGLOC@h?$AAi?$AA?$AA?$AA@
+; CHECK: const char16_t * {u"hi"}
+
+??_C@_0EK@FEAOBHPP@o?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA@
+; CHECK: const char16_t * {u"o123456789012345"...}
+
+??_C@_0M@GFNAJIPG@h?$AA?$AA?$AAi?$AA?$AA?$AA?$AA?$AA?$AA?$AA@
+; CHECK: const char32_t * {U"hi"}
+
+??_C@_0JE@IMHFEDAA@0?$AA?$AA?$AA1?$AA?$AA?$AA2?$AA?$AA?$AA3?$AA?$AA?$AA4?$AA?$AA?$AA5?$AA?$AA?$AA6?$AA?$AA?$AA7?$AA?$AA?$AA@
+; CHECK: const char32_t * {U"01234567"...}
+
+; These all have just the right length that the trailing 0 just fits.
+??_C@_0CA@NMANGEKF@012345678901234567890123456789A?$AA@
+; CHECK: const char * {"012345678901234567890123456789A"}
+
+??_C@_1EA@LJAFPILO@?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AAA?$AA?$AA@
+; CHECK: const wchar_t * {L"012345678901234567890123456789A"}
+
+??_C@_0CA@NMANGEKF@012345678901234567890123456789A?$AA@
+; CHECK: const char * {"012345678901234567890123456789A"}
+
+??_C@_0CA@NFEFHIFO@0?$AA1?$AA2?$AA3?$AA4?$AA5?$AA6?$AA7?$AA8?$AA9?$AA0?$AA1?$AA2?$AA3?$AA4?$AA?$AA?$AA@
+; CHECK: const char16_t * {u"012345678901234"}
+
+??_C@_0CA@KFPHPCC@0?$AA?$AA?$AA1?$AA?$AA?$AA2?$AA?$AA?$AA3?$AA?$AA?$AA4?$AA?$AA?$AA5?$AA?$AA?$AA6?$AA?$AA?$AA?$AA?$AA?$AA?$AA@
+; CHECK: const char32_t * {U"0123456"}
 No newline at end of file