Demangler plugin API

Closes #467

6 files changed, 4624 insertions, 0 deletions

diff --git a/demangler/gnu3/CMakeLists.txt b/demangler/gnu3/CMakeLists.txt
new file mode 100644
index 00000000..b7b4b149
--- /dev/null
+++ b/demangler/gnu3/CMakeLists.txt
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
+
+project(demangle_gnu3)
+
+file(GLOB SOURCES
+	*.cpp
+	*.c
+	*.h)
+
+add_library(${PROJECT_NAME} SHARED ${SOURCES})
+
+if(NOT BN_INTERNAL_BUILD)
+    # Out-of-tree build
+    find_path(
+        BN_API_PATH
+        NAMES binaryninjaapi.h
+        HINTS ../../.. binaryninjaapi $ENV{BN_API_PATH}
+        REQUIRED
+    )
+    add_subdirectory(${BN_API_PATH} api)
+endif()
+
+target_link_libraries(${PROJECT_NAME} binaryninjaapi)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+	CXX_STANDARD 17
+	CXX_VISIBILITY_PRESET hidden
+	CXX_STANDARD_REQUIRED ON
+	C_STANDARD 99
+	C_STANDARD_REQUIRED ON
+	C_VISIBILITY_PRESET hidden
+	VISIBILITY_INLINES_HIDDEN ON
+	POSITION_INDEPENDENT_CODE ON)
+
+if(BN_INTERNAL_BUILD)
+	plugin_rpath(${PROJECT_NAME})
+	set_target_properties(${PROJECT_NAME} PROPERTIES
+		LIBRARY_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR}
+		RUNTIME_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR})
+endif()
diff --git a/demangler/gnu3/demangle_gnu3.cpp b/demangler/gnu3/demangle_gnu3.cpp
new file mode 100644
index 00000000..412003d1
--- /dev/null
+++ b/demangler/gnu3/demangle_gnu3.cpp
@@ -0,0 +1,2373 @@
+// Copyright 2016-2024 Vector 35 Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Includes snippets from LLVM, which is under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+
+#include "binaryninjaapi.h"
+#include <stdarg.h>
+#include <algorithm>
+#include <memory>
+#include "demangle_gnu3.h"
+
+
+using namespace BinaryNinja;
+using namespace std;
+
+
+#define MAX_DEMANGLE_LENGTH    4096
+#define hash(x,y) (64 * x + y)
+
+#undef GNUDEMANGLE_DEBUG
+#ifdef GNUDEMANGLE_DEBUG  // This makes it not thread safe!
+static string _indent = "";
+#define indent() _indent += " ";
+#define dedent() do {if (_indent.size() > 0) _indent = _indent.substr(1);}while(0);
+
+void MyLogDebug(string fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	PerformLog(0, DebugLog, (_indent + fmt).c_str(), args);
+	va_end(args);
+}
+#else
+#define indent()
+#define dedent()
+void MyLogDebug(string fmt, ...)
+{ (void)fmt; }
+#endif
+
+static inline void rtrim(string &s)
+{
+	s.erase(find_if(s.rbegin(), s.rend(), [](int c) { return !isspace(c); }).base(), s.end());
+}
+
+
+static string GetTemplateString(vector<FunctionParameter> args)
+{
+	string name = "<";
+	for (size_t i = 0; i < args.size(); i++)
+	{
+		if (i != 0)
+		{
+			name += ", ";
+		}
+
+		name += args[i].name;
+	}
+	rtrim(name);
+	if (name.back() == '>')
+		name += " "; //Be c++03 compliant where we can
+	name += ">";
+	return name;
+}
+
+
+static void ExtendTypeName(TypeBuilder& type, const string& extend)
+{
+	QualifiedName qn = type.GetTypeName();
+	if (qn.StringSize() + extend.size() > MAX_DEMANGLE_LENGTH)
+		throw DemangleException("Detected adversarial mangled string");
+	if (qn.size() > 0)
+		qn.back() += extend;
+	else
+		qn.push_back(extend);
+	type.SetTypeName(qn);
+}
+
+
+static TypeBuilder CreateUnknownType(const QualifiedName& s)
+{
+	return TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass, s));
+}
+
+
+static TypeBuilder CreateUnknownType(const string& s)
+{
+	return TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass, {s}));
+}
+
+DemangleGNU3::Reader::Reader(const string& data): m_data(data), m_offset(0)
+{}
+
+
+string DemangleGNU3::Reader::PeekString(size_t count)
+{
+	if (count > Length())
+		return "\0";
+	return m_data.substr(m_offset, count);
+}
+
+
+char DemangleGNU3::Reader::Peek()
+{
+	if (1 > Length())
+		return '\0';
+	return (char)m_data[m_offset];
+}
+
+
+bool DemangleGNU3::Reader::NextIsOneOf(const string& list)
+{
+	char elm = Peek();
+	for (auto a : list)
+	{
+		if (a == elm)
+			return true;
+	}
+	return false;
+}
+
+
+string DemangleGNU3::Reader::GetRaw()
+{
+	return m_data.substr(m_offset);
+}
+
+
+char DemangleGNU3::Reader::Read()
+{
+	if (1 > Length())
+		throw DemangleException();
+	return m_data[m_offset++];
+}
+
+
+string DemangleGNU3::Reader::ReadString(size_t count)
+{
+	if (count > Length())
+		throw DemangleException();
+
+	const string out = m_data.substr(m_offset, count);
+	m_offset += count;
+	return out;
+}
+
+
+string DemangleGNU3::Reader::ReadUntil(char sentinal)
+{
+	size_t pos = m_data.find_first_of(sentinal, m_offset);
+	if (pos == string::npos)
+		throw DemangleException();
+	return ReadString(pos);
+}
+
+
+void DemangleGNU3::Reader::UnRead(size_t count)
+{
+	if (count <= m_offset)
+		m_offset -= count;
+}
+
+
+void DemangleGNU3::Reader::Consume(size_t count)
+{
+	if (count > Length())
+		throw DemangleException();
+	m_offset += count;
+}
+
+
+size_t DemangleGNU3::Reader::Length() const
+{
+	return m_data.length() - m_offset;
+}
+
+
+DemangleGNU3::DemangleGNU3(Architecture* arch, const string& mangledName) :
+	m_reader(mangledName),
+	m_arch(arch),
+	m_isParameter(false),
+	m_shouldDeleteReader(true),
+	m_topLevel(true),
+	m_isOperatorOverload(false)
+{
+	MyLogDebug("%s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+}
+
+
+void DemangleGNU3::PushTemplateType(TypeBuilder type)
+{
+	m_templateSubstitute.push_back(type);
+}
+
+
+const TypeBuilder& DemangleGNU3::GetTemplateType(size_t ref)
+{
+	if (ref >= m_templateSubstitute.size())
+	{
+		// PrintTables();
+		throw DemangleException();
+	}
+	return m_templateSubstitute[ref];
+}
+
+
+void DemangleGNU3::PushType(TypeBuilder type)
+{
+	m_substitute.push_back(type);
+}
+
+
+const TypeBuilder& DemangleGNU3::GetType(size_t ref)
+{
+	if (ref >= m_substitute.size())
+	{
+		// PrintTables();
+		throw DemangleException();
+	}
+	return m_substitute[ref];
+}
+
+
+void DemangleGNU3::PrintTables()
+{
+	LogDebug("Substitution Table\n");
+	for (int i = 0; (size_t)i < m_substitute.size(); i++)
+	{
+		LogDebug("[%d] %s\n", i-1, GetType(i).GetString().c_str());
+	}
+
+	LogDebug("Template Table\n");
+	for (int i = 0; (size_t)i < m_templateSubstitute.size(); i++)
+	{
+		LogDebug("[%d] %s\n", i-1, GetTemplateType(i).GetString().c_str());
+	}
+}
+
+
+void DemangleGNU3::DemangleCVQualifiers(bool& cnst, bool& vltl, bool& rstrct)
+{
+	cnst = false; vltl = false; rstrct = false;
+	//[<cv-qualifier>]
+	while (1)
+	{
+		switch (m_reader.Peek())
+		{
+		case 'r': rstrct = true; break;
+		case 'V': vltl = true; break;
+		case 'K': cnst = true; break;
+		default: return;
+		}
+		m_reader.Consume(1);
+	}
+}
+
+
+string DemangleGNU3::DemangleSourceName()
+{
+	indent();
+	MyLogDebug("%s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	m_lastName = m_reader.ReadString(DemangleNumber());
+	dedent();
+	return m_lastName;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleFunction(bool cnst, bool vltl)
+{
+	indent();
+	MyLogDebug("%s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	bool old_isparam;
+	if (m_reader.Peek() == 'Y')
+	{
+		// TODO: This function is external, should we do anything with that info?
+		m_reader.Consume();
+	}
+
+	TypeBuilder retType = DemangleType();
+
+	vector<FunctionParameter> params;
+	old_isparam = m_isParameter;
+	m_isParameter = true;
+	m_functionSubstitute.push_back({});
+	int i = 0;
+	while (m_reader.Peek() != 'E')
+	{
+		TypeBuilder param = DemangleType();
+		if (param.GetClass() == VoidTypeClass)
+			continue;
+		MyLogDebug("Var_%d - %s\n", i++, param.GetString().c_str());
+		m_functionSubstitute.back().push_back(param);
+		params.push_back({"", param.Finalize(), true, Variable()});
+	}
+	m_reader.Consume();
+	m_functionSubstitute.pop_back();
+	m_isParameter = old_isparam;
+	TypeBuilder newType = TypeBuilder::FunctionType(retType.Finalize(), nullptr, params);
+	PushType(newType);
+
+	newType.SetConst(cnst);
+	newType.SetVolatile(vltl);
+
+	if (cnst || vltl)
+		PushType(newType);
+	MyLogDebug("After %s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	dedent();
+	return newType;
+}
+
+
+const TypeBuilder& DemangleGNU3::DemangleTemplateSubstitution()
+{
+	indent();
+	MyLogDebug("%s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	size_t number = 0;
+	char elm = m_reader.Peek();
+	if (elm == '_')
+	{
+		number = 0;
+	}
+	else if (isdigit(elm))
+	{
+		m_reader.Consume();
+		number = elm - '0' + 1;
+	}
+	else if (isupper(elm))
+	{
+		m_reader.Consume();
+		number = elm - 'A' + 11;
+	}
+	else
+	{
+		throw DemangleException();
+	}
+
+	if (m_reader.Read() != '_')
+	{
+		throw DemangleException();
+	}
+	dedent();
+	return GetTemplateType(number);
+}
+
+
+TypeBuilder DemangleGNU3::DemangleType()
+{
+	indent();
+	MyLogDebug("%s : %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	TypeBuilder type;
+	bool cnst = false, vltl = false, rstrct = false;
+	bool substitute = false;
+	QualifiedName name;
+
+	DemangleCVQualifiers(cnst, vltl, rstrct);
+
+	if (cnst || vltl || rstrct)
+	{
+		type = DemangleType();
+		if (cnst)
+			type.SetConst(true);
+		if (vltl)
+			type.SetVolatile(true);
+		if (rstrct)
+			type.SetPointerSuffix({RestrictSuffix});
+		PushType(type);
+		return type;
+	}
+
+	switch(m_reader.Read())
+	{
+	case 'S':
+	{
+		if (isdigit(m_reader.Peek()) || m_reader.Peek() == '_' || isupper(m_reader.Peek()))
+		{
+			type = DemangleSubstitution();
+			if (m_reader.Peek() == 'I')
+			{
+				m_reader.Consume();
+				vector<FunctionParameter> args;
+				DemangleTemplateArgs(args);
+				ExtendTypeName(type, GetTemplateString(args));
+				type.SetHasTemplateArguments(true);
+				substitute = true;
+			}
+		}
+		else
+		{
+			if (m_reader.Peek() == 't')
+			{
+				m_reader.Consume(1);
+				type = DemangleUnqualifiedName();
+				QualifiedName qn = type.GetTypeName();
+				qn.insert(qn.begin(), "std");
+				type.SetTypeName(qn);
+				substitute = true;
+			}
+			else
+			{
+				type = DemangleSubstitution();
+			}
+			if (m_reader.Peek() == 'I')
+			{
+				m_reader.Consume();
+				if (substitute)
+					PushType(type);
+				vector<FunctionParameter> args;
+				DemangleTemplateArgs(args);
+				ExtendTypeName(type, GetTemplateString(args));
+				type.SetHasTemplateArguments(true);
+				substitute = true;
+			}
+		}
+		break;
+	}
+	case 'T':
+	{
+		/*  <class-enum-type> ::= <name>     # non-dependent type name, dependent type name, or dependent typename-specifier
+		                      ::= Ts <name>  # dependent elaborated type specifier using 'struct' or 'class'
+		                      ::= Tu <name>  # dependent elaborated type specifier using 'union'
+		                      ::= Te <name>  # dependent elaborated type specifier using 'enum'
+		*/
+		if (m_reader.Peek() == 's')
+		{
+			m_reader.Consume();
+			type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				StructNamedTypeClass, {DemangleSourceName()}));
+			break;
+		}
+		else if (m_reader.Peek() == 'u')
+		{
+			m_reader.Consume();
+			type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				UnionNamedTypeClass, {DemangleSourceName()}));
+			break;
+		}
+		else if (m_reader.Peek() == 'e')
+		{
+			m_reader.Consume();
+			type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				EnumNamedTypeClass, {DemangleSourceName()}),
+				m_arch->GetDefaultIntegerSize(), m_arch->GetDefaultIntegerSize());
+			break;
+		}
+
+		//Template Substitution
+		type = DemangleTemplateSubstitution();
+		substitute = true;
+		if (m_reader.Peek() == 'I')
+		{
+			m_reader.Consume();
+			if (substitute)
+				PushType(type);
+			vector<FunctionParameter> args;
+			DemangleTemplateArgs(args);
+			ExtendTypeName(type, GetTemplateString(args));
+			type.SetHasTemplateArguments(true);
+		}
+		break;
+	}
+	case 'P':
+		type = TypeBuilder::PointerType(m_arch, DemangleType().Finalize(), cnst, vltl, PointerReferenceType);
+		substitute = true;
+		break;
+	case 'R':
+		type = TypeBuilder::PointerType(m_arch, DemangleType().Finalize(), cnst, vltl, ReferenceReferenceType);
+		substitute = true;
+		break;
+	case 'O':
+		type = TypeBuilder::PointerType(m_arch, DemangleType().Finalize(), cnst, vltl, RValueReferenceType);
+		substitute = true;
+		break;
+	case 'C': //TODO:complex
+	case 'G': //TODO:imaginary
+	case 'U': //TODO:vendor extended type
+		throw DemangleException();
+	case 'v': type = TypeBuilder::VoidType(); break;
+	case 'w': type = TypeBuilder::IntegerType(4, false, "wchar_t"); break; //TODO: verify
+	case 'b': type = TypeBuilder::BoolType(); break;
+	case 'c': type = TypeBuilder::IntegerType(1, true); break;
+	case 'a': type = TypeBuilder::IntegerType(1, true); break;
+	case 'h': type = TypeBuilder::IntegerType(1, false); break;
+	case 's': type = TypeBuilder::IntegerType(2, true); break;
+	case 't': type = TypeBuilder::IntegerType(2, false); break;
+	case 'i': type = TypeBuilder::IntegerType(4, true); break;
+	case 'j': type = TypeBuilder::IntegerType(4, false); break;
+	case 'l': type = TypeBuilder::IntegerType(m_arch->GetAddressSize(), true); break; //long
+	case 'm': type = TypeBuilder::IntegerType(m_arch->GetAddressSize(), false); break; //ulong
+	case 'x': type = TypeBuilder::IntegerType(8, true); break;
+	case 'y': type = TypeBuilder::IntegerType(8, false); break;
+	case 'n': type = TypeBuilder::IntegerType(16, true); break;
+	case 'o': type = TypeBuilder::IntegerType(16, false); break;
+	case 'f': type = TypeBuilder::FloatType(4); break;
+	case 'd': type = TypeBuilder::FloatType(8); break;
+	case 'e': type = TypeBuilder::FloatType(10); break;
+	case 'g': type = TypeBuilder::FloatType(16); break;
+	case 'z': type = TypeBuilder::VarArgsType(); break;
+	case 'M': // TODO: Make into pointer to function member
+	{
+		TypeBuilder name = DemangleType();
+		TypeBuilder member = DemangleType();
+		string fullName = member.GetStringBeforeName() + "(" + name.GetString() + "::*)" + member.GetStringAfterName();
+		//member.SetScope(NonStaticScope);
+		//TypeBuilder ptr = TypeBuilder::PointerType(m_arch, member, cnst, vltl);
+		//QualifiedName qn({name.GetString(), "*"});
+		type = CreateUnknownType(fullName);
+		break;
+	}
+	case 'F': type = DemangleFunction(cnst, vltl); break;
+	case 'D':
+		switch (m_reader.Read())
+		{
+		case 'd': type = TypeBuilder::FloatType(8); break;
+		case 'e': type = TypeBuilder::FloatType(16); break;
+		case 'f': type = TypeBuilder::FloatType(4); break;
+		case 'h': type = TypeBuilder::FloatType(2); break;
+		case 'i': type = TypeBuilder::IntegerType(4, true, "char32_t"); break;
+		case 's': type = TypeBuilder::IntegerType(2, true, "char16_t"); break;
+		case 'a': type = CreateUnknownType("auto"); break; //auto type
+		case 'c': type = CreateUnknownType("decltype(auto)"); break; //decltype(auto)
+		case 'n':
+		{
+			static const QualifiedName stdNullptrTName(vector<string>{"std", "nullptr_t"});
+			type = CreateUnknownType(stdNullptrTName);
+			break;
+		}
+		case 'p': type = DemangleType(); break;
+		case 't':
+		case 'T':
+			type = CreateUnknownType(DemangleExpression());
+			if (m_reader.Read() != 'E')
+				throw DemangleException();
+			break;
+		case 'v':
+		{
+			// vector of size
+			uint64_t size = DemangleNumber();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			type = TypeBuilder::ArrayType(DemangleType().Finalize(), size);
+			break;
+		}
+		default:
+			MyLogDebug("Unsupported type: %s:'%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+			throw DemangleException();
+		}
+		break;
+	case 'N':
+		type = DemangleNestedName();
+		substitute = true;
+		break;
+	case 'A':
+		//  <array-type> ::= A <positive dimension number> _ <element type>
+		//               ::= A [<dimension expression>] _ <element type>
+		if (isdigit(m_reader.Peek()))
+		{
+			//<positive dimension number> _ <element type>
+			uint64_t size = DemangleNumber();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			type = TypeBuilder::ArrayType(DemangleType().Finalize(), size);
+		}
+		else
+		{
+			//[<dimension expression>] _ <element type>
+			//Since our type system doesn't support expressions as dimensions
+			//we instead demangle this as just a string.
+			string dimension = "[]";
+			if (m_reader.Peek() != '_')
+			{
+				dimension = "[" + DemangleExpression() + "]";
+			}
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+
+			const string typeString = DemangleType().GetString() + dimension;
+			type = CreateUnknownType(typeString);
+		}
+		substitute = true;
+		break;
+	default:
+	{
+		m_reader.UnRead();
+
+		type = DemangleName();
+		auto nameList = type.GetTypeName();
+		if (nameList.size() < 1)
+			throw DemangleException();
+		m_lastName = nameList.back();
+		substitute = true;
+
+		if (m_reader.Peek() == 'I')
+		{
+			substitute = false;
+			m_reader.Consume();
+			PushType(type);
+			vector<FunctionParameter> args;
+			DemangleTemplateArgs(args);
+			ExtendTypeName(type, GetTemplateString(args));
+			type.SetHasTemplateArguments(true);
+			PushType(type);
+		}
+	}
+	}
+
+	if (substitute)
+		PushType(type);
+
+	dedent();
+	return type;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleSubstitution()
+{
+	static const QualifiedName stdAllocatorName(vector<string>{"std", "allocator"});
+	static const QualifiedName stdBasicStringName(vector<string>{"std", "basic_string"});
+	static const QualifiedName stdIostreamName(vector<string>{"std", "iostream"});
+	static const QualifiedName stdIstreamName(vector<string>{"std", "istream"});
+	static const QualifiedName stdOstreamName(vector<string>{"std", "ostream"});
+	static const QualifiedName stdStringName(vector<string>{"std", "string"});
+	static const QualifiedName stdName(vector<string>{"std"});
+
+	indent()
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	char elm;
+	elm = m_reader.Read();
+	QualifiedName name;
+	size_t number = 0;
+	switch (elm)
+	{
+	case 'a': name = stdAllocatorName; break;
+	case 'b': name = stdBasicStringName; break;
+	case 'd': name = stdIostreamName; break;
+	case 'i': name = stdIstreamName; break;
+	case 'o': name = stdOstreamName; break;
+	case 's': name = stdStringName; break;
+	case 't': name = stdName; break;
+	default:
+		if (elm == '_')
+		{
+			m_reader.UnRead(1);
+			number = 0;
+		}
+		else if (isdigit(elm))
+		{
+			number = elm - '0' + 1;
+		}
+		else if (isupper(elm))
+		{
+			number = elm - 'A' + 11;
+		}
+		else
+		{
+			// PrintTables();
+			throw DemangleException();
+		}
+
+		if (m_reader.Read() != '_')
+		{
+			throw DemangleException();
+		}
+
+		dedent();
+		return GetType(number);
+	}
+	m_lastName = name.back();
+	dedent();
+	return CreateUnknownType(name);
+}
+
+string DemangleGNU3::DemangleNumberAsString()
+{
+	bool negativeFactor = false;
+	if ( m_reader.Peek() == 'n')
+	{
+		negativeFactor = true;
+		m_reader.Consume();
+	}
+
+	string number;
+	while (isdigit(m_reader.Peek()))
+	{
+		number += m_reader.ReadString(1);
+	}
+	return (negativeFactor?"-":"") + number;
+}
+
+// number ::= [n] <decimal>
+int64_t DemangleGNU3::DemangleNumber()
+{
+	return std::stol(DemangleNumberAsString().c_str());
+}
+
+
+string DemangleGNU3::DemangleInitializer()
+{
+	string out;
+	if (m_reader.ReadString(2) != "pi")
+		throw DemangleException();
+	out += "(";
+	while (m_reader.Peek() != 'E')
+		out += DemangleExpression();
+	m_reader.Consume();
+	out += ")";
+	return out;
+}
+
+static int8_t HexToDec(char c)
+{
+	if (isdigit(c))
+	{
+		return c - '0';
+	}
+	else if(islower(c) && c <= 'f')
+	{
+		return c - 'a' + 10;
+	}
+	return -1;
+}
+
+string DemangleGNU3::DemanglePrimaryExpression()
+{
+	indent();
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	char elm1 = '\0';
+	string out;
+	QualifiedName tmpList;
+	string valueString;
+	float f; double d; long double ld;
+	bool oldTopLevel;
+	//expr-primary
+	if (m_reader.PeekString(2) == "_Z")
+	{
+		m_reader.Consume(2);
+		oldTopLevel = m_topLevel;
+		m_topLevel = false;
+		TypeBuilder t = DemangleSymbol(tmpList);
+		m_topLevel = oldTopLevel;
+		out += t.GetStringBeforeName();
+		out += tmpList.GetString();
+		out += t.GetStringAfterName();
+		dedent()
+		return out;
+	}
+	switch (m_reader.Read())
+	{
+	case 'b':
+		elm1 = m_reader.Read();
+		if (elm1 == '0')
+			out += "false";
+		else if (elm1 == '1')
+			out += "true";
+		else
+			throw DemangleException();
+		break;
+	case 'd': //double
+		valueString = m_reader.ReadString(8);
+
+		for (size_t i = 0; i < valueString.size(); i+=2)
+		{
+			((unsigned char*)&d)[i/2] = (HexToDec(valueString[i]) << 16) + HexToDec(valueString[i+1]);
+		}
+		out += to_string(d);
+		break;
+	case 'e': //long double
+		valueString = m_reader.ReadString(10);
+
+		for (size_t i = 0; i < valueString.size(); i+=2)
+		{
+			((unsigned char*)&ld)[i/2] = (HexToDec(valueString[i]) << 16) + HexToDec(valueString[i+1]);
+		}
+		out += to_string(ld);
+		break;
+	case 'f': //float
+		valueString = m_reader.ReadString(4);
+
+		for (size_t i = 0; i < valueString.size(); i+=2)
+		{
+			((unsigned char*)&f)[i/2] = (HexToDec(valueString[i]) << 16) + HexToDec(valueString[i+1]);
+		}
+		out += to_string(f);
+		break;
+	case 'g': //float_128
+		valueString = m_reader.ReadString(16); //We read 16 but then just throw away
+
+		for (size_t i = 0; i < 10; i+=2)
+		{
+			((unsigned char*)&ld)[i/2] = (HexToDec(valueString[i]) << 16) + HexToDec(valueString[i+1]);
+		}
+		out += to_string(ld);
+		break;
+	case 'l': out = DemangleNumberAsString() + "l"; break;  //long
+	case 'x': out = DemangleNumberAsString() + "ll"; break;  //long long
+	case 's': out = "(short)" + DemangleNumberAsString(); break; //short
+	case 'n': out = "(__uint128)" + DemangleNumberAsString() + "ull"; break;  //__int128
+	case 'i': out = DemangleNumberAsString(); break;       // int
+	case 'm': out = DemangleNumberAsString() + "ul"; break;  //unsigned long
+	case 't': out = "(unsigned short)" + DemangleNumberAsString(); break; //unsigned short
+	case 'y': out = DemangleNumberAsString() + "ull"; break;  //unsigned long long
+	case 'j': out = DemangleNumberAsString() + "u"; break; // unsigned int
+		break;
+	default:
+		m_reader.UnRead(1);
+		out = "(" + DemangleTypeString() + ")" + DemangleNumberAsString();
+		break;
+	}
+	if (m_reader.Read() != 'E')
+		throw DemangleException();
+
+	dedent();
+	return out;
+}
+
+
+string DemangleGNU3::DemangleUnarySuffixExpression(const string& op)
+{
+	return "(" + DemangleExpression() + ")" + op;
+}
+
+
+string DemangleGNU3::DemangleUnaryPrefixExpression(const string& op)
+{
+	return op + "(" + DemangleExpression() + ")";
+}
+
+
+string DemangleGNU3::DemangleBinaryExpression(const string& op)
+{
+	indent();
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	const string lhs = "(" + DemangleExpression() + ")";
+	const string rhs = "(" + DemangleExpression() + ")";
+	dedent();
+	if (op == ".")
+		return lhs + op + rhs;
+	return lhs + " " + op + " " + rhs;
+}
+
+
+string DemangleGNU3::DemangleUnaryPrefixType(const string& op)
+{
+	return op + "(" + DemangleTypeString() + ")";
+}
+
+
+string DemangleGNU3::DemangleTypeString()
+{
+	return DemangleType().GetString();
+}
+
+
+string DemangleGNU3::DemangleExpressionList()
+{
+	indent();
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	string expr;
+	bool first = true;
+	m_functionSubstitute.push_back({});
+	while (m_reader.Peek() != 'E')
+	{
+		if (!first)
+			expr += ", ";
+		const string e = DemangleExpression();
+		expr += e;
+		m_functionSubstitute.back().push_back(CreateUnknownType(e));
+		first = false;
+	}
+	m_functionSubstitute.pop_back();
+	m_reader.Consume();
+	dedent();
+	return expr;
+}
+
+static string GetOperator(char elm1, char elm2)
+{
+	switch (hash(elm1, elm2))
+	{
+	case hash('d','c'): return "dynamic_cast";
+	case hash('s','c'): return "static_cast";
+	case hash('c','c'): return "const_cast";
+	case hash('r','c'): return "reinterpret_cast";
+	case hash('t','i'): return "typeid";
+	case hash('t','e'): return "typeid";
+	case hash('s','t'): return "sizeof";
+	case hash('s','z'): return "sizeof";
+	case hash('a','t'): return "alignof";
+	case hash('a','z'): return "alignof";
+	case hash('n','x'): return "noexcept";
+	case hash('s','Z'): return "sizeof...";
+	case hash('s','P'): return "sizeof...";
+	case hash('s','p'): return "";
+	case hash('t','w'): return "throw";
+	case hash('t','r'): return "throw";
+	case hash('l','s'): return "<<";  // <<
+	case hash('r','s'): return ">>";  // >>
+	case hash('a','S'): return "=";   // =
+	case hash('n','t'): return "!";   // !
+	case hash('e','q'): return "==";  // ==
+	case hash('n','e'): return "!=";  // !=
+	case hash('i','x'): return "[]";  // []
+	case hash('d','t'): return ".";   // .
+	case hash('p','t'): return "->";  // ->
+	case hash('m','l'): return "*";   // *
+	case hash('p','p'): return "++";  // ++ (postfix in <expression> context)
+	case hash('m','m'): return "--";  // -- (postfix in <expression> context)
+	case hash('n','g'): return "-";   // - (unary)
+	case hash('m','i'): return "-";   // -
+	case hash('p','s'): return "+";   // + (unary)
+	case hash('p','l'): return "+";   // +
+	case hash('a','d'): return "&";   // & (unary)
+	case hash('a','n'): return "&";   // &
+	case hash('p','m'): return "->*"; // ->*
+	case hash('d','v'): return "/";   // /
+	case hash('r','m'): return "%";   // %
+	case hash('l','t'): return "<";   // <
+	case hash('l','e'): return "<=";  // <=
+	case hash('g','t'): return ">";   // >
+	case hash('g','e'): return ">=";  // >=
+	case hash('c','m'): return ",";   // ,
+	case hash('c','l'): return "()";  // ()
+	case hash('c','o'): return "~";   // ~
+	case hash('e','o'): return "^";   // ^
+	case hash('o','r'): return "|";   // |
+	case hash('a','a'): return "&&";  // &&
+	case hash('o','o'): return "||";  // ||
+	case hash('d','e'): return "*";   // * (unary)
+	case hash('m','L'): return "*=";  // *=
+	case hash('p','L'): return "+=";  // +=
+	case hash('m','I'): return "-=";  // -=
+	case hash('d','V'): return "/=";  // /=
+	case hash('r','M'): return "%=";  // %=
+	case hash('r','S'): return ">>="; // >>=
+	case hash('l','S'): return "<<="; // <<=
+	case hash('a','N'): return "&=";  // &=
+	case hash('o','R'): return "|=";  // |=
+	case hash('e','O'): return "^=";  // ^=
+	case hash('d','l'): return "delete";   // delete
+	case hash('d','a'): return "delete[]"; // delete[]
+	case hash('n','w'): return "new";      // new
+	case hash('n','a'): return "new[]";    // new []
+	default: return "";
+	}
+}
+
+static BNNameType GetNameType(char elm1, char elm2)
+{
+	switch (hash(elm1, elm2))
+	{
+	case hash('n','t'): return OperatorNotNameType;              // !
+	case hash('n','g'): return OperatorMinusNameType;       // - (unary)
+	case hash('p','s'): return OperatorPlusNameType;        // + (unary)
+	case hash('a','d'): return OperatorBitAndNameType;      // & (unary)
+	case hash('d','e'): return OperatorStarNameType;        // * (unary)
+	case hash('i','x'): return OperatorArrayNameType;            // []
+	case hash('p','p'): return OperatorIncrementNameType;        // ++ (postfix in <expression> context)
+	case hash('m','m'): return OperatorDecrementNameType;        // -- (postfix in <expression> context)
+	case hash('l','s'): return OperatorLeftShiftNameType;        // <<
+	case hash('r','s'): return OperatorRightShiftNameType;       // >>
+	case hash('a','S'): return OperatorAssignNameType;           // =
+	case hash('e','q'): return OperatorEqualNameType;            // ==
+	case hash('n','e'): return OperatorNotEqualNameType;         // !=
+	case hash('p','t'): return OperatorArrowNameType;            // ->
+	case hash('m','l'): return OperatorStarNameType;             // *
+	case hash('m','i'): return OperatorMinusNameType;            // -
+	case hash('p','l'): return OperatorPlusNameType;             // +
+	case hash('a','n'): return OperatorBitAndNameType;           // &
+	case hash('p','m'): return OperatorArrowStarNameType;        // ->*
+	case hash('d','v'): return OperatorDivideNameType;           // /
+	case hash('r','m'): return OperatorModulusNameType;          // %
+	case hash('l','t'): return OperatorLessThanNameType;         // <
+	case hash('l','e'): return OperatorLessThanEqualNameType;    // <=
+	case hash('g','t'): return OperatorGreaterThanNameType;      // >
+	case hash('g','e'): return OperatorGreaterThanEqualNameType; // >=
+	case hash('c','m'): return OperatorCommaNameType;           // ,
+	case hash('c','l'): return OperatorParenthesesNameType;     // ()
+	case hash('c','o'): return OperatorTildeNameType;           // ~
+	case hash('e','o'): return OperatorXorNameType;             // ^
+	case hash('o','r'): return OperatorBitOrNameType;           // |
+	case hash('a','a'): return OperatorLogicalAndNameType;      // &&
+	case hash('o','o'): return OperatorLogicalOrNameType;       // ||
+	case hash('m','L'): return OperatorStarEqualNameType;       // *=
+	case hash('p','L'): return OperatorPlusEqualNameType;       // +=
+	case hash('m','I'): return OperatorMinusEqualNameType;      // -=
+	case hash('d','V'): return OperatorDivideEqualNameType;     // /=
+	case hash('r','M'): return OperatorModulusEqualNameType;    // %=
+	case hash('r','S'): return OperatorRightShiftEqualNameType; // >>=
+	case hash('l','S'): return OperatorLeftShiftEqualNameType;  // <<=
+	case hash('a','N'): return OperatorAndEqualNameType;        // &=
+	case hash('o','R'): return OperatorOrEqualNameType;         // |=
+	case hash('e','O'): return OperatorXorEqualNameType;        // ^=
+	case hash('d','l'): return OperatorDeleteNameType;          // delete
+	case hash('d','a'): return OperatorDeleteArrayNameType;     // delete[]
+	case hash('n','w'): return OperatorNewNameType;             // new
+	case hash('n','a'): return OperatorNewArrayNameType;        // new []
+	case hash('C','1'): return ConstructorNameType;
+	case hash('C','2'): return ConstructorNameType;
+	case hash('C','3'): return ConstructorNameType;
+	case hash('C','4'): return ConstructorNameType;
+	case hash('C','5'): return ConstructorNameType;
+	case hash('D','0'): return DestructorNameType;
+	case hash('D','1'): return DestructorNameType;
+	case hash('D','2'): return DestructorNameType;
+	case hash('D','3'): return DestructorNameType;
+	case hash('D','4'): return DestructorNameType;
+	case hash('D','5'): return DestructorNameType;
+	default:
+		return NoNameType;
+	}
+}
+
+TypeBuilder DemangleGNU3::DemangleUnqualifiedName()
+{
+	indent()
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+
+	TypeBuilder outType;
+	char elm1 = m_reader.Read();
+	char elm2 = m_reader.Read();
+	switch (hash(elm1, elm2))
+	{
+	case hash('n','t'): // !
+	case hash('n','g'): // - (unary)
+	case hash('p','s'): // + (unary)
+	case hash('a','d'): // & (unary)
+	case hash('d','e'): // * (unary)
+	case hash('i','x'): // []
+	case hash('p','p'): // ++ (postfix in <expression> context)
+	case hash('m','m'): // -- (postfix in <expression> context)
+	case hash('l','s'): // <<
+	case hash('r','s'): // >>
+	case hash('a','S'): // =
+	case hash('e','q'): // ==
+	case hash('n','e'): // !=
+	case hash('p','t'): // ->
+	case hash('d','t'): // .
+	case hash('m','l'): // *
+	case hash('m','i'): // -
+	case hash('p','l'): // +
+	case hash('a','n'): // &
+	case hash('p','m'): // ->*
+	case hash('d','v'): // /
+	case hash('r','m'): // %
+	case hash('l','t'): // <
+	case hash('l','e'): // <=
+	case hash('g','t'): // >
+	case hash('g','e'): // >=
+	case hash('c','m'): // ,
+	case hash('c','l'): // ()
+	case hash('c','o'): // ~
+	case hash('e','o'): // ^
+	case hash('o','r'): // |
+	case hash('a','a'): // &&
+	case hash('o','o'): // ||
+	case hash('m','L'): // *=
+	case hash('p','L'): // +=
+	case hash('m','I'): // -=
+	case hash('d','V'): // /=
+	case hash('r','M'): // %=
+	case hash('r','S'): // >>=
+	case hash('l','S'): // <<=
+	case hash('a','N'): // &=
+	case hash('o','R'): // |=
+	case hash('e','O'): // ^=
+		outType = CreateUnknownType("operator" + GetOperator(elm1, elm2));
+		outType.SetNameType(GetNameType(elm1, elm2));
+		break;
+	case hash('t','i'):
+	case hash('t','e'):
+	case hash('s','t'):
+	case hash('s','z'):
+	case hash('a','t'):
+	case hash('a','z'):
+	case hash('n','x'):
+	case hash('s','Z'):
+	case hash('s','P'):
+	case hash('s','p'):
+	case hash('d','l'): // delete
+	case hash('d','a'): // delete[]
+	case hash('n','w'): // new
+	case hash('n','a'): // new []
+		outType = CreateUnknownType("operator " + GetOperator(elm1, elm2));
+		outType.SetNameType(GetNameType(elm1, elm2));
+		break;
+	case hash('v','0'):
+	case hash('v','1'):
+	case hash('v','2'):
+	case hash('v','3'):
+	case hash('v','4'):
+	case hash('v','5'):
+	case hash('v','6'):
+	case hash('v','7'):
+	case hash('v','8'):
+	case hash('v','9'):
+		//TODO: Unsupported vendor extended types
+		throw DemangleException();
+	case hash('C','1'): //Construtor
+	case hash('C','2'):
+	case hash('C','3'):
+	case hash('C','4'):
+	case hash('C','5'):
+		outType = CreateUnknownType(m_lastName);
+		outType.SetNameType(ConstructorNameType);
+		break;
+	case hash('D','0'): //Destructor
+	case hash('D','1'):
+	case hash('D','2'):
+	case hash('D','3'):
+	case hash('D','4'):
+	case hash('D','5'):
+		outType = CreateUnknownType("~" + m_lastName);
+		outType.SetNameType(DestructorNameType);
+		break;
+	case hash('D','t'):
+	case hash('D','T'):
+		outType = CreateUnknownType(DemangleExpression());
+		// if (m_reader.Read() != 'E')
+		// 	throw DemangleException();
+		break;
+	case hash('U','l'): //Lambda
+	{
+		string name;
+		name = "'lambda";
+		vector<TypeBuilder> params;
+		do
+		{
+			TypeBuilder param = DemangleType();
+			if (param.GetClass() == VoidTypeClass)
+				break;
+			params.push_back(std::move(param));
+		}while (m_reader.Peek() != 'E');
+		m_reader.Consume();
+
+		if (isdigit(m_reader.Peek()))
+		{
+			name += DemangleNumberAsString();
+		}
+		if (m_reader.Read() != '_')
+			throw DemangleException();
+
+		name += "'(";
+		for (size_t i = 0; i < params.size(); i++)
+		{
+			if (i != 0)
+				name += ", ";
+			name += params[i].GetString();
+		}
+		name += ")";
+		m_lastName = name;
+		outType = CreateUnknownType(name);
+		break;
+	}
+	case hash('U','t'):
+	{
+		string name;
+		name = "'unnamed";
+
+		if (isdigit(m_reader.Peek()))
+		{
+			name += DemangleNumberAsString();
+		}
+		name += "\'";
+
+		if (m_reader.Read() != '_')
+			throw DemangleException();
+
+		m_lastName = name;
+		outType = CreateUnknownType(name);
+		break;
+	}
+	case hash('c','v'): //type (expression)
+		outType = CreateUnknownType("operator " + DemangleType().GetString());
+		break;
+	default:
+		m_reader.UnRead(2);
+		if (isdigit(m_reader.Peek()) || m_reader.Read() == 'L')
+		{
+			string name = DemangleSourceName();
+			if (name.size() > 11 && name.substr(0, 11) == "_GLOBAL__N_")
+				name = "(anonymous namespace)";
+			outType = CreateUnknownType(name);
+		}
+		else
+		{
+			throw DemangleException();
+		}
+	}
+	dedent();
+	return outType;
+}
+
+
+QualifiedName DemangleGNU3::DemangleBaseUnresolvedName()
+{
+	// <base-unresolved-name> ::= <simple-id>                                # unresolved name
+	//                        ::= on <operator-name>                         # unresolved operator-function-id
+	//                        ::= on <operator-name> <template-args>         # unresolved operator template-id
+	//                        ::= dn <destructor-name>                       # destructor or pseudo-destructor;
+	//                                                                       # e.g. ~X or ~X<N-1>
+
+	indent()
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	QualifiedName out;
+	if (m_reader.Length() > 1)
+	{
+		const string str = m_reader.PeekString(2);
+		if (str == "on")
+		{
+			out.push_back(GetOperator(m_reader.Read(), m_reader.Read()));
+			if (m_reader.Peek() == 'I')
+			{
+				m_reader.Consume();
+				vector<FunctionParameter> args;
+				DemangleTemplateArgs(args);
+				out.back() += GetTemplateString(args);
+				PushType(CreateUnknownType(out));
+			}
+		}
+		else if (str == "dn")
+		{
+			string name = DemangleUnresolvedType().GetString();
+			if (name.empty())
+				out.push_back("~" + DemangleSourceName());
+			else
+				out.push_back("~" + name);
+		}
+		else
+		{
+			// <simple-id>
+			out.push_back(DemangleSourceName());
+			if (m_reader.Peek() == 'I')
+			{
+				m_reader.Consume();
+				vector<FunctionParameter> args;
+				DemangleTemplateArgs(args);
+				out.back() += GetTemplateString(args);
+			}
+		}
+	}
+	dedent();
+	return out;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleUnresolvedType()
+{
+	indent();
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	//<unresolved-type> ::= <template-param> [ <template-args> ]            # T:: or T<X,Y>::
+	//                  ::= <decltype>                                      # decltype(p)::
+	//                  ::= <substitution>
+	TypeBuilder type;
+	if (m_reader.Peek() == 'T')
+	{
+		m_reader.Consume();
+		type = DemangleTemplateSubstitution();
+		if (m_reader.Peek() == 'I')
+		{
+			PushType(type);
+			m_reader.Consume();
+			vector<FunctionParameter> args;
+			DemangleTemplateArgs(args);
+			ExtendTypeName(type, GetTemplateString(args));
+			type.SetHasTemplateArguments(true);
+			PushType(type);
+		}
+	}
+	else if (m_reader.Length() > 2 && (m_reader.PeekString(2) == "Dt" || m_reader.PeekString(2) == "DT"))
+	{
+		const string name = "decltype(" + DemangleExpression() + ")";
+		type = CreateUnknownType(name);
+	}
+	else if (m_reader.Peek() == 'S')
+	{
+		m_reader.Consume();
+		type = DemangleSubstitution();
+	}
+	else
+	{
+		throw DemangleException();
+	}
+	dedent();
+	return type;
+}
+
+
+string DemangleGNU3::DemangleExpression()
+{
+	MyLogDebug("%s: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	/*
+	<expression> ::= <unary operator-name> <expression>
+	               ::= <binary operator-name> <expression> <expression>
+	               ::= <ternary operator-name> <expression> <expression> <expression>
+	               ::= pp_ <expression>                                     # prefix ++
+	               ::= mm_ <expression>                                     # prefix --
+	               ::= cl <expression>+ E                                   # expression (expr-list), call
+	               ::= cv <type> <expression>                               # type (expression), conversion with one argument
+	               ::= cv <type> _ <expression>* E                          # type (expr-list), conversion with other than one argument
+	               ::= tl <type> <expression>* E                            # type {expr-list}, conversion with braced-init-list argument
+	               ::= il <expression> E                                    # {expr-list}, braced-init-list in any other context
+	               ::= [gs] nw <expression>* _ <type> E                     # new (expr-list) type
+	               ::= [gs] nw <expression>* _ <type> <initializer>         # new (expr-list) type (init)
+	               ::= [gs] na <expression>* _ <type> E                     # new[] (expr-list) type
+	               ::= [gs] na <expression>* _ <type> <initializer>         # new[] (expr-list) type (init)
+	               ::= [gs] dl <expression>                                 # delete expression
+	               ::= [gs] da <expression>                                 # delete[] expression
+	               ::= dc <type> <expression>                               # dynamic_cast<type> (expression)
+	               ::= sc <type> <expression>                               # static_cast<type> (expression)
+	               ::= cc <type> <expression>                               # const_cast<type> (expression)
+	               ::= rc <type> <expression>                               # reinterpret_cast<type> (expression)
+	               ::= ti <type>                                            # typeid (type)
+	               ::= te <expression>                                      # typeid (expression)
+	               ::= st <type>                                            # sizeof (type)
+	               ::= sz <expression>                                      # sizeof (expression)
+	               ::= at <type>                                            # alignof (type)
+	               ::= az <expression>                                      # alignof (expression)
+	               ::= nx <expression>                                      # noexcept (expression)
+	               ::= <template-param>
+	               ::= <function-param>
+	               ::= dt <expression> <unresolved-name>                    # expr.name
+	               ::= pt <expression> <unresolved-name>                    # expr->name
+	               ::= ds <expression> <expression>                         # expr.*expr
+	               ::= sZ <template-param>                                  # sizeof...(T), size of a template parameter pack
+	               ::= sZ <function-param>                                  # sizeof...(parameter), size of a function parameter pack
+	               ::= sP <template-arg>* E                                 # sizeof...(T), size of a captured template parameter pack from an alias template
+	               ::= sp <expression>                                      # expression..., pack expansion
+	               ::= tw <expression>                                      # throw expression
+	               ::= tr                                                   # throw with no operand (rethrow)
+	               ::= <unresolved-name>                                    # f(p), N::f(p), ::f(p),
+	                                                                        # freestanding dependent name (e.g., T::x),
+	                                                                        # objectless nonstatic member reference
+	               ::= <expr-primary>
+	*/
+	char elm1 = '\0', elm2 = '\0';
+	string gs, out;
+	elm1 = m_reader.Read();
+	if (elm1 == 'L')
+	{
+		out = DemanglePrimaryExpression();
+		return out;
+	}
+	else if (elm1 == 'T') //<template-param>
+	{
+		return DemangleTemplateSubstitution().GetString();
+	}
+
+	elm2 = m_reader.Read();
+	if (hash(elm1, elm2) == hash('g', 's'))
+	{
+		elm1 = m_reader.Read();
+		elm2 = m_reader.Read();
+		switch (hash(elm1, elm2))
+		{
+		case hash('s','r'):
+		case hash('n','w'):
+		case hash('n','a'):
+		case hash('d','l'):
+		case hash('d','a'): break;
+		default:
+			throw DemangleException();
+		}
+		gs = "::";
+	}
+
+	switch (hash(elm1, elm2))
+	{
+	case hash('d','c'):
+	case hash('s','c'):
+	case hash('c','c'):
+	case hash('r','c'):
+		return GetOperator(elm1, elm2) + "<" + DemangleTypeString() + ">(" + DemangleExpression() + ")";
+	case hash('t','i'):
+	case hash('t','e'):
+	case hash('s','t'):
+	case hash('s','z'):
+	case hash('a','t'):
+	case hash('a','z'):
+	case hash('n','x'):
+		return GetOperator(elm1, elm2) + "(" + DemangleTypeString() + ")";
+	case hash('s','Z'):
+		return GetOperator(elm1, elm2) + "(" + DemangleTypeString() + ")";
+	case hash('s','P'):
+	{
+		vector<FunctionParameter> args;
+		DemangleTemplateArgs(args);
+		return "sizeof...(" + GetTemplateString(args) + ")...";
+	}
+	case hash('s','p'):
+		return "(" + DemangleExpression() + ")...";
+	case hash('t','w'):
+		return GetOperator(elm1, elm2) + DemangleExpression();
+	case hash('t','r'):
+		return GetOperator(elm1, elm2); //rethrow
+	case hash('n','t'): // !
+	case hash('n','g'): // - (unary)
+	case hash('p','s'): // + (unary)
+	case hash('a','d'): // & (unary)
+	case hash('d','e'): // * (unary)
+		return DemangleUnaryPrefixExpression(GetOperator(elm1, elm2));
+	case hash('i','x'): // []
+	case hash('p','p'): // ++ (postfix in <expression> context)
+	case hash('m','m'): // -- (postfix in <expression> context)
+		return DemangleUnarySuffixExpression(GetOperator(elm1, elm2));
+	case hash('l','s'): // <<
+	case hash('r','s'): // >>
+	case hash('a','S'): // =
+	case hash('e','q'): // ==
+	case hash('n','e'): // !=
+	case hash('d','t'): // .
+	case hash('p','t'): // ->
+	case hash('m','l'): // *
+	case hash('m','i'): // -
+	case hash('p','l'): // +
+	case hash('a','n'): // &
+	case hash('p','m'): // ->*
+	case hash('d','v'): // /
+	case hash('r','m'): // %
+	case hash('l','t'): // <
+	case hash('l','e'): // <=
+	case hash('g','t'): // >
+	case hash('g','e'): // >=
+	case hash('c','m'): // ,
+	case hash('c','o'): // ~
+	case hash('e','o'): // ^
+	case hash('o','r'): // |
+	case hash('a','a'): // &&
+	case hash('o','o'): // ||
+	case hash('m','L'): // *=
+	case hash('p','L'): // +=
+	case hash('m','I'): // -=
+	case hash('d','V'): // /=
+	case hash('r','M'): // %=
+	case hash('r','S'): // >>=
+	case hash('l','S'): // <<=
+	case hash('a','N'): // &=
+	case hash('o','R'): // |=
+	case hash('e','O'): // ^=
+		return DemangleBinaryExpression(GetOperator(elm1, elm2));
+	case hash('d','l'): // delete
+	case hash('d','a'): // delete[]
+	case hash('n','w'): // new
+	case hash('n','a'): // new []
+		return gs + DemangleUnaryPrefixType(GetOperator(elm1, elm2));
+	case hash('q','u'): // ternary
+		return DemangleExpression() + "?" +
+		       DemangleExpression() + ":" +
+		       DemangleExpression();
+	case hash('c','l'): // ()
+		return "(" + DemangleExpressionList() + ")";
+	case hash('c','v'): //type (expression)
+	{
+		TypeBuilder type = DemangleType();
+		out = type.GetString();
+		if (m_reader.Peek() == '_')
+			out += " (" + DemangleExpressionList() + ")";
+		else
+			out += " (" + DemangleExpression() + ")";
+		return out;
+	}
+	case hash('t','l'): //type {expression}
+		return DemangleTypeString() + " {" + DemangleExpressionList() + "}";
+	case hash('i', 'l'): //{expr-list}, braced-init-list in any other context
+		out = DemangleExpression();
+		if (m_reader.Read() != 'E')
+			throw DemangleException();
+		return out;
+	case hash('f','p'):
+	case hash('f','L'):
+	{
+		//<function-param> ::= fp <CV> _                         # L == 0, first parameter
+		//                 ::= fp <CV> <prm-2 num> _             # L == 0, second and later parameters
+		//                 ::= fL <L-1 num> p <CV> _             # L  > 0, first parameter
+		//                 ::= fL <L-1 num> p <CV> <prm-2 num> _ # L  > 0, second and later parameters
+
+		bool cnst = false, vltl = false, rstrct = false;
+		TypeBuilder type;
+		int64_t listNumber = 0;
+		int64_t elementNum = 0;
+		char elm;
+		if (m_functionSubstitute.size() == 0)
+			throw DemangleException();
+
+		if (elm2 == 'L')
+		{
+			listNumber = DemangleNumber() + 1;
+			if (listNumber < 0 ||
+			    (uint64_t)listNumber >= (uint64_t)m_functionSubstitute.size() ||
+			    m_reader.Read() != 'p')
+				throw DemangleException();
+		}
+		DemangleCVQualifiers(cnst, vltl, rstrct);
+		elm = m_reader.Peek();
+		if (elm == '_')
+		{
+			m_reader.Consume(1);
+			if ((size_t)elementNum >= m_functionSubstitute[listNumber].size())
+			{
+				throw DemangleException();
+			}
+			type = m_functionSubstitute[listNumber][elementNum];
+		}
+		else if (isdigit(elm) || isupper(elm))
+		{
+			elementNum = DemangleNumber() + 1;
+			if (m_reader.Read() != '_' ||
+			    elementNum < 0 ||
+			    (size_t)elementNum >= m_functionSubstitute[listNumber].size())
+			{
+				throw DemangleException();
+			}
+			type = m_functionSubstitute[listNumber][elementNum];
+		}
+		else
+		{
+			throw DemangleException();
+		}
+		out = type.GetString();
+		break;
+	}
+	case hash('s','r'):
+		/*
+		<unresolved-name> ::=
+		                  ::=   <unresolved-type> <base-unresolved-name>                  # T::x / decltype(p)::x
+		                  ::= N <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
+		                                                                                    # T::N::x /decltype(p)::N::x
+		                  ::=                     <unresolved-qualifier-level>+ E <base-unresolved-name>
+		                                                            # A::x, N::y, A<T>::z; "gs" means leading "::"
+
+		<unresolved-type> ::= <template-param> [ <template-args> ]            # T:: or T<X,Y>::
+		                  ::= <decltype>                                      # decltype(p)::
+		                  ::= <substitution>
+
+		<unresolved-qualifier-level> ::= <simple-id>
+		<base-unresolved-name> ::= <simple-id>                                # unresolved name
+		                       ::= on <operator-name>                         # unresolved operator-function-id
+		                       ::= on <operator-name> <template-args>         # unresolved operator template-id
+		                       ::= dn <destructor-name>                       # destructor or pseudo-destructor;
+		                                                                      # e.g. ~X or ~X<N-1>
+		*/
+		if (m_reader.Peek() == 'N')
+		{
+			m_reader.Consume();
+			out += DemangleUnresolvedType().GetString() + "::";
+			do
+			{
+				out += DemangleSourceName();
+				PushType(TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+					UnknownNamedTypeClass, out)));
+				if (m_reader.Peek() == 'I')
+				{
+					vector<FunctionParameter> args;
+					m_reader.Consume();
+					//<tmplate-args>
+					DemangleTemplateArgs(args);
+					out += GetTemplateString(args);
+				}
+				out += "::";
+			}while (m_reader.Peek() != 'E');
+			m_reader.Consume();
+
+			out += DemangleBaseUnresolvedName().GetString();
+			return out;
+		}
+		if (isdigit(m_reader.Peek()))
+		{
+			do
+			{
+				out += DemangleSourceName();
+				if (m_reader.Peek() == 'I')
+				{
+					vector<FunctionParameter> args;
+					m_reader.Consume();
+					//<tmplate-args>
+					DemangleTemplateArgs(args);
+					out += GetTemplateString(args);
+				}
+				out += "::";
+			}while (m_reader.Peek() != 'E');
+			m_reader.Consume();
+			out += DemangleBaseUnresolvedName().GetString();
+			return out;
+		}
+		else
+		{
+			out += DemangleUnresolvedType().GetString() + "::";
+			out += DemangleBaseUnresolvedName().GetString();
+		}
+		return out;
+	default:
+		m_reader.UnRead(2);
+		out = DemangleSourceName();
+		if (m_reader.Peek() == 'I')
+		{
+			vector<FunctionParameter> args;
+			m_reader.Consume();
+			//<tmplate-args>
+			DemangleTemplateArgs(args);
+			out += GetTemplateString(args);
+		}
+		break;
+	}
+	return out;
+}
+
+
+void DemangleGNU3::DemangleTemplateArgs(vector<FunctionParameter>& args)
+{
+	indent();
+	MyLogDebug("%s:: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	TypeBuilder tmp;
+	bool tmpValid = false;
+	string expr;
+	bool topLevel;
+	const string lastName = m_lastName;
+	while (m_reader.Peek() != 'E')
+	{
+		switch (m_reader.Read())
+		{
+		case 'L':
+			expr = DemanglePrimaryExpression();
+			args.push_back({expr, nullptr, true, Variable()});
+			tmp = CreateUnknownType(expr);
+			tmpValid = true;
+			break;
+		case 'X':
+			args.push_back({DemangleExpression(), nullptr, true, Variable()});
+			if (m_reader.Read() != 'E')
+				throw DemangleException();
+			break;
+		case 'J':
+			DemangleTemplateArgs(args);
+			break;
+		default:
+			m_reader.UnRead();
+			topLevel = m_topLevel;
+			m_topLevel = false;
+			tmp = DemangleType();
+			m_topLevel = topLevel;
+			args.push_back({tmp.GetString(), nullptr, true, Variable()});
+			tmpValid = true;
+		}
+		if (m_topLevel && tmpValid)
+		{
+			MyLogDebug("Adding template ref: %s\n", tmp.GetString().c_str());
+			PushTemplateType(tmp);
+		}
+	}
+	m_reader.Consume();
+	m_lastName = lastName;
+	dedent();
+	return;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleNestedName()
+{
+	/*
+	This can be either a qualified name like: "foo::bar::bas"
+	or it can be a qualified type like: "foo::bar::bas & const" thus we return either
+	a name or a type.
+
+	<nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
+	              ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
+
+	<prefix> ::= <unqualified-name>                 # global class or namespace
+	         ::= <prefix> <unqualified-name>        # nested class or namespace
+	         ::= <template-prefix> <template-args>  # class template specialization
+	         ::= <template-param>                   # template type parameter
+	         ::= <decltype>                         # decltype qualifier
+	         ::= <prefix> <data-member-prefix>      # initializer of a data member
+	         ::= <substitution>
+
+	<template-prefix> ::= <template unqualified-name>           # global template
+	                  ::= <prefix> <template unqualified-name>  # nested template
+	                  ::= <template-param>                      # template template parameter
+	                  ::= <substitution>
+
+	<unqualified-name> ::= <operator-name>
+	                   ::= <ctor-dtor-name>
+	                   ::= <source-name>
+	                   ::= <unnamed-type-name>
+
+	<source-name> ::= <positive length number> <identifier>
+	<identifier>  ::= <unqualified source code identifier>
+	*/
+
+	indent();
+	MyLogDebug("%s:: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	TypeBuilder type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+		UnknownNamedTypeClass, QualifiedName()));
+	bool cnst = false, vltl = false, rstrct = false;
+	bool ref = false;
+	bool rvalueRef = false;
+	bool substitute = true;
+	TypeBuilder newType;
+	bool base = false;
+	bool isTemplate = false;
+	bool hasB = false;
+	//[<CV-qualifiers>]
+	DemangleCVQualifiers(cnst, vltl, rstrct);
+
+	//[<ref-qualifier>]
+	if (m_reader.Peek() == 'R')
+	{
+		m_reader.Consume();
+		ref = true;
+	}
+	else if (m_reader.Peek() == 'O')
+	{
+		m_reader.Consume();
+		ref = true;
+		rvalueRef = true;
+	}
+
+	while (m_reader.Peek() != 'E')
+	{
+		if (m_reader.Peek() == 'B')
+		{
+			hasB = true;
+			break;
+		}
+		isTemplate = false;
+		substitute = true;
+		size_t startSize = m_templateSubstitute.size();
+		switch (m_reader.Read())
+		{
+		case 'S': //<substitution>
+			newType = DemangleSubstitution();
+			substitute = false;
+			break;
+		case 'T': //<template-param>
+			newType = DemangleTemplateSubstitution();
+			break;
+		case 'I': //<template-prefix> <template-args>
+		{
+			if (!base)
+				throw DemangleException();
+			vector<FunctionParameter> args;
+			DemangleTemplateArgs(args);
+			ExtendTypeName(type, GetTemplateString(args));
+			type.SetHasTemplateArguments(true);
+			isTemplate = true;
+			break;
+		}
+		default:  //<unqualified-name> || <decltype>
+			m_reader.UnRead(1);
+			newType = DemangleUnqualifiedName();
+			break;
+		}
+
+		base = true;
+		if (!isTemplate)
+		{
+			type.SetNameType(newType.GetNameType());
+			QualifiedName newName = type.GetTypeName() + newType.GetTypeName();
+			if (newName.StringSize() > MAX_DEMANGLE_LENGTH)
+				throw DemangleException("Detected adversarial mangled string");
+			type.SetTypeName(newName);
+			type.SetHasTemplateArguments(false);
+		}
+		if (substitute && m_reader.Peek() != 'E')
+		{
+			//Those template arguments were not the primary arguments so clear them from the sub listType
+			while (m_templateSubstitute.size() > startSize)
+			{
+				m_templateSubstitute.pop_back();
+			}
+			PushType(type);
+		}
+		MyLogDebug("%s:: '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	}
+	if (!hasB)
+		m_reader.Consume();
+
+	if (cnst || vltl || rstrct)
+	{
+		type.SetConst(cnst);
+		type.SetVolatile(vltl);
+		if (rstrct)
+			type.AddPointerSuffix(RestrictSuffix);
+	}
+
+	if (ref)
+	{
+		type.AddPointerSuffix(rvalueRef?LvalueSuffix:ReferenceSuffix);
+		PushType(type);
+	}
+	dedent();
+	return type;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleLocalName()
+{
+	indent();
+	MyLogDebug("%s '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	TypeBuilder type;
+	QualifiedName varName;
+	bool oldTopLevel = m_topLevel;
+	m_topLevel = false;
+	type = DemangleSymbol(varName);
+	m_topLevel = oldTopLevel;
+
+	if (varName.size() > 0)
+		varName.back() += (type.GetStringAfterName());
+	else
+		varName.push_back(type.GetString());
+
+	if (m_reader.Peek() != 's')
+	{
+		//<entity name>
+		TypeBuilder tmpType = DemangleName();
+		type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass, varName));
+		QualifiedName newName = type.GetTypeName() + tmpType.GetTypeName();
+		if (newName.StringSize() > MAX_DEMANGLE_LENGTH)
+			throw DemangleException("Detected adversarial mangled string");
+		type.SetTypeName(newName);
+		type.SetConst(tmpType.IsConst());
+		type.SetVolatile(tmpType.IsVolatile());
+		type.SetPointerSuffix(tmpType.GetPointerSuffix());
+	}
+	else
+	{
+		m_reader.Consume();
+		type = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass, varName));
+	}
+	// [<discriminator>]
+	//TODO: What do we do with discriminators?
+	if (m_reader.Peek() == '_')
+	{
+		m_reader.Consume();
+		if (m_reader.Peek() == '_')
+		{
+			m_reader.Consume();
+			DemangleNumberAsString();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+		}
+		else
+		{
+			DemangleNumberAsString();
+		}
+	}
+	dedent();
+	return type;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleName()
+{
+	indent();
+	MyLogDebug("%s '%s'\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	/*
+	<name> ::= <nested-name>
+	       ::= <unscoped-name>
+	       ::= <unscoped-template-name> <template-args>
+	       ::= <local-name>	# See Scope Encoding below
+
+	<unscoped-name> ::= <unqualified-name>
+	                ::= St <unqualified-name>   # ::std::
+
+	<unscoped-template-name> ::= <unscoped-name>
+	                         ::= <substitution>
+	*/
+	TypeBuilder type;
+	bool substitute = false;
+	switch (m_reader.Read())
+	{
+	case 'S':
+		if (m_reader.Peek() == 't')
+		{
+			m_reader.Consume(1);
+			type = DemangleUnqualifiedName();
+			QualifiedName qn = type.GetTypeName();
+			qn.insert(qn.begin(), "std");
+			type.SetTypeName(qn);
+			substitute = true;
+		}
+		else
+		{
+			type = DemangleSubstitution();
+		}
+
+		if (m_reader.Peek() == 'I')
+		{
+			m_reader.Consume();
+			if (substitute)
+				PushType(type);
+			vector<FunctionParameter> args;
+			DemangleTemplateArgs(args);
+			ExtendTypeName(type, GetTemplateString(args));
+			type.SetHasTemplateArguments(true);
+		}
+		break;
+	case 'N': //<nested-name>
+		type = DemangleNestedName();
+		break;
+	case 'Z': //<local-name>
+		type = DemangleLocalName();
+		break;
+	default: //<unscoped-name> | <substitution>
+		/*
+		<unscoped-name> ::= <unqualified-name>
+		                ::= St <unqualified-name>   # ::std::
+		<unscoped-template-name> ::= <unscoped-name>
+		                         ::= <substitution>
+		*/
+		m_reader.UnRead();
+		if (m_reader.Peek() == 'L')
+			m_reader.Consume();
+		type = DemangleUnqualifiedName();
+		if (m_reader.Peek() == 'I')
+		{
+			PushType(type);
+			//<unscoped-template-name>
+			vector<FunctionParameter> args;
+			m_reader.Consume();
+			//<tmplate-args>
+			DemangleTemplateArgs(args);
+			LogDebug("Typename: %s", type.GetTypeName()[0].c_str());
+			ExtendTypeName(type, GetTemplateString(args));
+			LogDebug("Typename: %s", type.GetTypeName()[0].c_str());
+			type.SetHasTemplateArguments(true);
+		}
+	}
+	dedent();
+	return type;
+}
+
+
+TypeBuilder DemangleGNU3::DemangleSymbol(QualifiedName& varName)
+{
+	indent();
+	MyLogDebug("%s: %s\n", __FUNCTION__, m_reader.GetRaw().c_str());
+	TypeBuilder returnType;
+	bool isReturnTypeUnknown = false;
+	TypeBuilder type;
+	vector<FunctionParameter> params;
+	bool cnst = false, vltl = false, rstrct = false;
+	bool oldTopLevel;
+	QualifiedName name;
+
+	/*
+	<encoding> ::= <function name> <bare-function-type>
+	           ::= <data name>
+	           ::= <special-name>
+	*/
+	//<special-name>
+	switch (m_reader.Peek())
+	{
+	case 'G':
+		m_reader.Consume();
+		switch (m_reader.Read())
+		{
+		case 'A': //TODO hidden alias
+			LogWarn("Unsupported demangle type: hidden alias\n");
+			throw DemangleException();
+		case 'R': //TODO reference temporaries
+			LogWarn("Unsupported demangle type: reference temporary\n");
+			throw DemangleException();
+		case 'T': //TODO transaction clones
+			LogWarn("Unsupported demangle type: transaction clone\n");
+			throw DemangleException();
+		case 'V':
+		{
+			TypeBuilder t = DemangleSymbol(name);
+			varName.push_back("guard_variable_for_" + t.GetTypeAndName(name));
+			type = TypeBuilder::IntegerType(1, false);
+			if (m_reader.Length() == 0)
+				return type;
+			//function parameters
+			string paramList;
+			paramList += "(";
+			bool first = true;
+			do
+			{
+				if (m_reader.Peek() == 'v')
+				{
+					m_reader.Consume();
+					break;
+				}
+				if (!first)
+					paramList += ", ";
+				paramList += DemangleTypeString();
+			}while (m_reader.Peek() != 'E');
+			m_reader.Consume();
+			varName.back() += paramList + ")";
+			varName.push_back(DemangleSourceName());
+			return type;
+		}
+		default:
+			throw DemangleException();
+		}
+	case 'T':
+		/*
+		<special-name> ::= TV <type>	# virtual table
+		               ::= TT <type>	# VTT structure (construction vtable index)
+		               ::= TI <type>	# typeinfo structure
+		               ::= TS <type>	# typeinfo name (null-terminated byte string)
+		               ::= T <call-offset> <base encoding>
+		                   # base is the nominal target function of thunk
+		<call-offset>  ::= h <nv-offset> _
+		               ::= v <v-offset> _
+		<nv-offset>    ::= <offset number> # non-virtual base override
+		<v-offset>     ::= <offset number> _ <virtual offset number>
+		                   # virtual base override, with vcall offset
+		*/
+		m_reader.Consume();
+		switch (m_reader.Read())
+		{
+		case 'c':
+			LogWarn("Unsupported: 'virtual function covariant override thunk'\n");
+			throw DemangleException();
+		case 'C':
+		{
+			TypeBuilder t = DemangleType();
+			DemangleNumberAsString();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+
+			return TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass,
+						{"construction_vtable_for_" + DemangleTypeString() + "-in-" + t.GetString()}));
+		}
+		case 'D':
+			LogWarn("Unsupported: 'typeinfo common proxy'\n");
+			throw DemangleException();
+		case 'F':
+			LogWarn("Unsupported: 'typeinfo fn'\n");
+			throw DemangleException();
+		case 'h': //TODO: Convert to whatever the actual type is!
+		{
+			DemangleNumberAsString();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			oldTopLevel = m_topLevel;
+			m_topLevel = false;
+			TypeBuilder t = DemangleSymbol(name);
+			m_topLevel = oldTopLevel;
+			return TypeBuilder::NamedType(
+					NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass,
+							{"non-virtual_thunk_to_" + name.GetString() + t.GetStringAfterName()}));
+		}
+		case 'H':
+			LogWarn("Unsupported: 'TLS init function'\n");
+			throw DemangleException();
+		case 'I':
+			return TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(StructNamedTypeClass,
+				{"typeinfo_for_" + DemangleTypeString()}));
+		case 'J':
+			LogWarn("Unsupported: 'java class'\n");
+			throw DemangleException();
+		case 'S':
+		{
+			TypeBuilder t = DemangleType();
+			varName = vector<string>{"typeinfo_name_for_" + t.GetString()};
+			return TypeBuilder::ArrayType(Type::IntegerType(1, true), 0);
+		}
+		case 'T': //VTT
+		{
+			TypeBuilder t = DemangleType();
+			return TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(StructNamedTypeClass,
+				{"VTT_for_" + t.GetString()}));
+		}
+		case 'v':  //TODO: Convert to whatever the actual type is!
+		{
+			DemangleNumberAsString();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			DemangleNumberAsString();
+			if (m_reader.Read() != '_')
+				throw DemangleException();
+			oldTopLevel = m_topLevel;
+			m_topLevel = false;
+			TypeBuilder t = DemangleSymbol(name);
+			m_topLevel = oldTopLevel;
+			return TypeBuilder::NamedType(
+						NamedTypeReference::GenerateAutoDemangledTypeReference(UnknownNamedTypeClass,
+							{"virtual_thunk_to_" + name.GetString() + t.GetStringAfterName()}));
+		}
+		case 'V': //Vtable
+			return TypeBuilder::NamedType(
+					NamedTypeReference::GenerateAutoDemangledTypeReference(StructNamedTypeClass,
+						{"vtable_for_" + DemangleTypeString()}));
+		case 'W':
+			MyLogDebug("Unsupported: 'TLS wrapper function'\n");
+			throw DemangleException();
+		default:
+			throw DemangleException();
+		}
+	default: break;
+	}
+
+	//<function name> or <data name>
+	type = DemangleName();
+	if (m_reader.Length() == 0)
+	{
+		return type;
+	}
+
+	if (m_reader.Peek() == 'E')
+	{
+		m_reader.Consume();
+		return type;
+	}
+
+	varName = type.GetTypeName();
+	cnst = type.IsConst();
+	vltl = type.IsVolatile();
+	set<BNPointerSuffix> suffix = type.GetPointerSuffix();
+	if (m_reader.Peek() == 'J')
+	{
+		m_reader.Consume();
+		// TODO: If we get here we have a return type. What can we do with this info?
+	}
+	if (m_reader.Peek() == 'B')
+	{
+		m_reader.Consume();
+		TypeBuilder t = DemangleUnqualifiedName();
+
+		if (t.GetString() == "cxx11")
+		{
+			static const QualifiedName stdCxx11StringName(vector<string>{"std", "cxx11", "string"});
+			returnType = CreateUnknownType(stdCxx11StringName);
+		}
+	}
+	else if (m_isOperatorOverload ||
+		type.GetNameType() == ConstructorNameType ||
+		type.GetNameType() == DestructorNameType)
+	{
+		returnType = TypeBuilder::VoidType();
+	}
+	else if (m_isParameter || type.HasTemplateArguments())
+	{
+		returnType = DemangleType();
+	}
+	else
+	{
+		isReturnTypeUnknown = true;
+		returnType = TypeBuilder::IntegerType(m_arch->GetAddressSize(), true);
+	}
+
+	m_functionSubstitute.push_back({});
+	for (size_t i = 0; m_reader.Length() > 0; i++)
+	{
+		if (m_reader.Peek() == 'E')
+		{
+			m_reader.Consume();
+			break;
+		}
+		if (m_reader.Peek() == '.')
+		{
+			// Extension, consume the rest
+			string ext = m_reader.ReadString(m_reader.Length());
+
+			if (ext == ".eh") ext = "exception handler";
+			else if (ext == ".eh_frame") ext = "exception handler frame";
+			else if (ext == ".eh_frame_hdr") ext = "exception handler frame header";
+			else if (ext == ".debug_frame") ext = "debug frame";
+			varName.back() += ext;
+			break;
+		}
+
+		m_isParameter = true;
+		MyLogDebug("Var_%d: %s\n", i, m_reader.GetRaw().c_str());
+		if (m_reader.PeekString(2) == "@@")
+			break;
+		TypeBuilder param = DemangleType();
+		if (param.GetClass() == VoidTypeClass)
+		{
+			if (m_reader.Peek() == 'E')
+			{
+				m_reader.Consume();
+				break;
+			}
+			break;
+		}
+		m_functionSubstitute.back().push_back(param);
+		params.push_back({"", param.Finalize(), true, Variable()});
+		if (param.GetClass() == VarArgsTypeClass)
+		{
+			if (m_reader.Peek() == 'E')
+			{
+				m_reader.Consume();
+			}
+
+			break;
+		}
+	}
+
+	m_functionSubstitute.pop_back();
+	m_isParameter = false;
+	type = TypeBuilder::FunctionType(returnType.Finalize()->
+		WithConfidence(isReturnTypeUnknown ? BN_MINIMUM_CONFIDENCE : BN_DEFAULT_CONFIDENCE), nullptr, params);
+
+	type.SetPointerSuffix(suffix);
+	type.SetConst(cnst);
+	type.SetVolatile(vltl);
+	if (rstrct)
+		type.SetPointerSuffix({RestrictSuffix});
+
+	// PrintTables();
+	MyLogDebug("Done: %s%s%s\n", type.GetStringBeforeName().c_str(), varName.GetString().c_str(),
+		type.GetStringAfterName().c_str());
+
+	dedent();
+	return type;
+}
+
+
+bool DemangleGNU3::IsGNU3MangledString(const string& name)
+{
+	string headerless = name;
+	string header;
+	if (DemangleGlobalHeader(headerless, header))
+		return true;
+
+	if (!headerless.compare(0, 2, "_Z") || !headerless.compare(0, 3, "__Z"))
+		return true;
+
+	return false;
+}
+
+
+bool DemangleGNU3::DemangleGlobalHeader(string& name, string& header)
+{
+	size_t strippedCount = 0;
+	string encoded = name;
+	while (encoded[0] == '_')
+	{
+		encoded.erase(0, 1);
+		strippedCount ++;
+	}
+
+	if (strippedCount == 0)
+		return false;
+
+	static const vector<pair<string, string>> headers = {
+		{"GLOBAL__sub_I_", "(static initializer)"},
+		{"GLOBAL__I_", "(global initializer)"},
+		{"GLOBAL__D_", "(global destructor)"},
+	};
+
+	for (auto& i: headers)
+	{
+		if (encoded.size() > i.first.size() && encoded.substr(0, i.first.size()) == i.first)
+		{
+			name = name.substr(i.first.size() + strippedCount);
+			header = i.second;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+bool DemangleGNU3::DemangleStringGNU3(Architecture* arch, const string& name, Ref<Type>& outType, QualifiedName& outVarName, const Ref<BinaryView>& view)
+{
+	return DemangleStringGNU3(arch, name, outType, outVarName);
+}
+
+
+bool DemangleGNU3::DemangleStringGNU3(Architecture* arch, const string& name, Ref<Type>& outType, QualifiedName& outVarName, BinaryView* view)
+{
+	return DemangleStringGNU3(arch, name, outType, outVarName);
+}
+
+
+bool DemangleGNU3::DemangleStringGNU3(Architecture* arch, const string& name, Ref<Type>& outType, QualifiedName& outVarName)
+{
+	string encoding = name;
+	string header;
+	bool foundHeader = DemangleGlobalHeader(encoding, header);
+
+	if (!encoding.compare(0, 2, "_Z"))
+		encoding = encoding.substr(2);
+	else if (!encoding.compare(0, 3, "__Z"))
+		encoding = encoding.substr(3);
+	else if (foundHeader && !header.empty())
+	{
+		// Some variable constructors/destructors are __GLOBAL__I_name
+		// And there are even __GLOBAL__sub_I_file_name.cpp
+		outVarName.clear();
+		outVarName.push_back(header);
+		outVarName.push_back(encoding);
+		outType = CreateUnknownType(outVarName).Finalize();
+		return true;
+	}
+	else
+		return false;
+
+	DemangleGNU3 demangle(arch, encoding);
+	try
+	{
+		outType = demangle.DemangleSymbol(outVarName).Finalize();
+
+		if (outVarName.size() == 0)
+		{
+			if (outType->GetClass() == NamedTypeReferenceClass && outType->GetNamedTypeReference()->GetTypeReferenceClass() == UnknownNamedTypeClass)
+			{
+				outVarName = outType->GetTypeName();
+				outType = nullptr;
+			}
+			else if (outType->GetClass() == NamedTypeReferenceClass)
+			{
+				auto typeName = outType->GetTypeName();
+				if (typeName.size() > 0)
+					outVarName = "_" + typeName[typeName.size() - 1];
+			}
+		}
+
+		if (foundHeader && !header.empty())
+		{
+			outVarName.insert(outVarName.begin(), header);
+		}
+	}
+	catch (std::exception&)
+	{
+		return false;
+	}
+	return true;
+}
+
+
+class GNU3Demangler: public Demangler
+{
+public:
+	GNU3Demangler(): Demangler("GNU3")
+	{
+	}
+	~GNU3Demangler() override {}
+
+	virtual bool IsMangledString(const string& name) override
+	{
+		return DemangleGNU3::IsGNU3MangledString(name);
+	}
+
+	virtual bool Demangle(Ref<Architecture> arch, const string& name, Ref<Type>& outType, QualifiedName& outVarName,
+	                      Ref<BinaryView> view) override
+	{
+		if (view)
+			return DemangleGNU3::DemangleStringGNU3(arch, name, outType, outVarName, view);
+		return DemangleGNU3::DemangleStringGNU3(arch, name, outType, outVarName);
+	}
+};
+
+
+extern "C"
+{
+	BN_DECLARE_CORE_ABI_VERSION
+
+#ifdef DEMO_EDITION
+	bool DemangleGNU3PluginInit()
+#else
+	BINARYNINJAPLUGIN bool CorePluginInit()
+#endif
+	{
+		static GNU3Demangler* demangler = new GNU3Demangler();
+		Demangler::Register(demangler);
+		return true;
+	}
+}
diff --git a/demangler/gnu3/demangle_gnu3.h b/demangler/gnu3/demangle_gnu3.h
new file mode 100644
index 00000000..ad1303e6
--- /dev/null
+++ b/demangler/gnu3/demangle_gnu3.h
@@ -0,0 +1,122 @@
+// Copyright 2016-2024 Vector 35 Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <stdexcept>
+#include <exception>
+#include "binaryninjaapi.h"
+
+
+class DemangleException: public std::exception
+{
+	std::string m_message;
+public:
+	DemangleException(std::string msg="Attempt to read beyond bounds or missing expected character"): m_message(msg){}
+	virtual const char* what() const noexcept { return m_message.c_str(); }
+};
+
+class DemangleGNU3
+{
+	class Reader
+	{
+	public:
+		Reader(const std::string& data);
+		std::string PeekString(size_t count=1);
+		char Peek();
+		bool NextIsOneOf(const std::string& list);
+		std::string GetRaw();
+		char Read();
+		std::string ReadString(size_t count=1);
+		std::string ReadUntil(char sentinal);
+		void Consume(size_t count=1);
+		size_t Length() const;
+		void UnRead(size_t count=1);
+	private:
+		std::string m_data;
+		size_t m_offset;
+	};
+
+	class SubstitutionList
+	{
+		std::vector<BinaryNinja::TypeBuilder> m_typeList;
+	public:
+		SubstitutionList();
+		~SubstitutionList();
+		void PushType(BinaryNinja::TypeBuilder t);
+		void PopType();
+		const BinaryNinja::TypeBuilder& GetType(size_t reference) const;
+		void PrintSubstitutionTable() const;
+		size_t Size() const { return m_typeList.size(); }
+		void Clear() { m_typeList.clear(); }
+	};
+
+	BinaryNinja::QualifiedName m_varName;
+	Reader m_reader;
+	BinaryNinja::Architecture* m_arch;
+	std::vector<BinaryNinja::TypeBuilder> m_substitute;
+	std::vector<BinaryNinja::TypeBuilder> m_templateSubstitute;
+	std::vector<std::vector<BinaryNinja::TypeBuilder>> m_functionSubstitute;
+	std::string m_lastName;
+	BNNameType m_nameType;
+	bool m_localType;
+	bool m_hasReturnType;
+	bool m_isParameter;
+	bool m_shouldDeleteReader;
+	bool m_topLevel;
+	bool m_isOperatorOverload;
+	enum SymbolType { Function, FunctionWithReturn, Data, VTable, Rtti, Name};
+	BinaryNinja::QualifiedName DemangleBaseUnresolvedName();
+	BinaryNinja::TypeBuilder DemangleUnresolvedType();
+	std::string DemangleUnarySuffixExpression(const std::string& op);
+	std::string DemangleUnaryPrefixExpression(const std::string& op);
+	std::string DemangleBinaryExpression(const std::string& op);
+	std::string DemangleUnaryPrefixType(const std::string& op);
+	std::string DemangleTypeString();
+	std::string DemangleExpressionList();
+	BinaryNinja::TypeBuilder DemangleUnqualifiedName();
+	std::string DemangleSourceName();
+	std::string DemangleNumberAsString();
+	std::string DemangleInitializer();
+	std::string DemangleExpression();
+	std::string DemanglePrimaryExpression();
+	BinaryNinja::TypeBuilder DemangleName();
+	BinaryNinja::TypeBuilder DemangleLocalName();
+
+	void DemangleCVQualifiers(bool& cnst, bool& vltl, bool& rstrct);
+	BinaryNinja::TypeBuilder DemangleSubstitution();
+	const BinaryNinja::TypeBuilder& DemangleTemplateSubstitution();
+	void DemangleTemplateArgs(std::vector<BinaryNinja::FunctionParameter>& args);
+	bool DemangleEncoding(BinaryNinja::Type** type, BinaryNinja::QualifiedName& outName);
+	BinaryNinja::TypeBuilder DemangleFunction(bool cnst, bool vltl);
+	BinaryNinja::TypeBuilder DemangleType();
+	int64_t DemangleNumber();
+	BinaryNinja::TypeBuilder DemangleNestedName();
+	void PushTemplateType(BinaryNinja::TypeBuilder type);
+	const BinaryNinja::TypeBuilder& GetTemplateType(size_t ref);
+	void PushType(BinaryNinja::TypeBuilder type);
+	const BinaryNinja::TypeBuilder& GetType(size_t ref);
+	static bool DemangleGlobalHeader(std::string& name, std::string& header);
+
+public:
+	DemangleGNU3(BinaryNinja::Architecture* arch, const std::string& mangledName);
+	BinaryNinja::TypeBuilder DemangleSymbol(BinaryNinja::QualifiedName& varName);
+	BinaryNinja::QualifiedName GetVarName() const { return m_varName; }
+	static bool IsGNU3MangledString(const std::string& name);
+
+	// Tread lightly on this landmine; a BinaryView* will be converted to a bool; use an explicit (BinaryNinja::Ref<BinaryNinja::BinaryView>)view cast
+	static bool DemangleStringGNU3(BinaryNinja::Architecture* arch, const std::string& name, BinaryNinja::Ref<BinaryNinja::Type>& outType, BinaryNinja::QualifiedName& outVarName, const BinaryNinja::Ref<BinaryNinja::BinaryView>& view);
+	static bool DemangleStringGNU3(BinaryNinja::Architecture* arch, const std::string& name, BinaryNinja::Ref<BinaryNinja::Type>& outType, BinaryNinja::QualifiedName& outVarName, BinaryNinja::BinaryView* view);
+	static bool DemangleStringGNU3(BinaryNinja::Architecture* arch, const std::string& name, BinaryNinja::Ref<BinaryNinja::Type>& outType, BinaryNinja::QualifiedName& outVarName);
+	void PrintTables();
+};
diff --git a/demangler/msvc/CMakeLists.txt b/demangler/msvc/CMakeLists.txt
new file mode 100644
index 00000000..222b4303
--- /dev/null
+++ b/demangler/msvc/CMakeLists.txt
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
+
+project(demangle_msvc)
+
+file(GLOB SOURCES
+	*.cpp
+	*.c
+	*.h)
+
+add_library(${PROJECT_NAME} SHARED ${SOURCES})
+
+if(NOT BN_INTERNAL_BUILD)
+    # Out-of-tree build
+    find_path(
+        BN_API_PATH
+        NAMES binaryninjaapi.h
+        HINTS ../../.. binaryninjaapi $ENV{BN_API_PATH}
+        REQUIRED
+    )
+    add_subdirectory(${BN_API_PATH} api)
+endif()
+
+target_link_libraries(${PROJECT_NAME} binaryninjaapi)
+
+set_target_properties(${PROJECT_NAME} PROPERTIES
+	CXX_STANDARD 17
+	CXX_VISIBILITY_PRESET hidden
+	CXX_STANDARD_REQUIRED ON
+	C_STANDARD 99
+	C_STANDARD_REQUIRED ON
+	C_VISIBILITY_PRESET hidden
+	VISIBILITY_INLINES_HIDDEN ON
+	POSITION_INDEPENDENT_CODE ON)
+
+if(BN_INTERNAL_BUILD)
+	plugin_rpath(${PROJECT_NAME})
+	set_target_properties(${PROJECT_NAME} PROPERTIES
+		LIBRARY_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR}
+		RUNTIME_OUTPUT_DIRECTORY ${BN_CORE_PLUGIN_DIR})
+endif()
diff --git a/demangler/msvc/demangle_msvc.cpp b/demangler/msvc/demangle_msvc.cpp
new file mode 100644
index 00000000..9571efe7
--- /dev/null
+++ b/demangler/msvc/demangle_msvc.cpp
@@ -0,0 +1,1887 @@
+// Copyright 2016-2024 Vector 35 Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Includes snippets from LLVM, which is under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+
+#include "binaryninjaapi.h"
+#include "demangle_msvc.h"
+#include <memory>
+
+using namespace BinaryNinja;
+using namespace std;
+
+#define MAX_DEMANGLE_LENGTH 4096
+
+Demangle::Reader::Reader(string data)
+{
+	m_data = data;
+	//Check for non-ascii characters
+	for (auto a : m_data)
+	{
+		if (a < 0x20 || a > 0x7e)
+			throw DemangleException();
+	}
+}
+
+
+string Demangle::Reader::PeekString(size_t count)
+{
+	if (count > Length())
+		throw DemangleException();
+	return m_data.substr(0, count);
+}
+
+
+char Demangle::Reader::Peek()
+{
+	if (1 > Length())
+		throw DemangleException();
+	return (char)m_data[0];
+}
+
+
+const char* Demangle::Reader::GetRaw()
+{
+	return m_data.c_str();
+}
+
+
+char Demangle::Reader::Read()
+{
+	if (1 > Length())
+		throw DemangleException();
+	char out = m_data[0];
+	m_data = m_data.substr(1);
+	return out;
+}
+
+
+string Demangle::Reader::ReadString(size_t count)
+{
+	if (count > Length())
+		throw DemangleException();
+	string out = m_data.substr(0, count);
+	m_data = m_data.substr(count + 1);
+	return out;
+}
+
+
+string Demangle::Reader::ReadUntil(char sentinal)
+{
+	size_t pos = m_data.find_first_of(sentinal);
+	if (pos == string::npos)
+		throw DemangleException();
+	return ReadString(pos);
+}
+
+
+void Demangle::Reader::Consume(size_t count)
+{
+	if (count > Length())
+		throw DemangleException();
+	m_data = m_data.substr(count);
+}
+
+
+size_t Demangle::Reader::Length()
+{
+	return m_data.length();
+}
+
+
+const TypeBuilder& Demangle::BackrefList::GetTypeBackref(size_t reference)
+{
+	if (reference < typeList.size())
+		return typeList[reference];
+	// LogDebug("type: %llx - : %d/%d\n", this, typeList.size(), reference);
+	throw DemangleException(string("Backref too large " + std::to_string(reference)));
+}
+
+
+string Demangle::BackrefList::GetStringBackref(size_t reference)
+{
+	// LogDebug("type: %llx - ref: %d\n", this, reference);
+	if (reference < nameList.size())
+		return nameList[reference];
+	LogDebug("type: %llx - Backref too large: %d/%d\n", this, nameList.size(), reference);
+	throw DemangleException(string("Backref too large " + std::to_string(reference)));
+}
+
+
+void Demangle::BackrefList::PushTypeBackref(TypeBuilder t)
+{
+	// LogDebug("this: %llx - TypeBackref: %lld  %s\n", this, nameList.size(), t.GetString().c_str());
+	if (typeList.size() <= 9)
+		typeList.push_back(t);
+}
+
+
+void Demangle::BackrefList::PushStringBackref(string& s)
+{
+	if (s.size() > MAX_DEMANGLE_LENGTH)
+		throw DemangleException();
+	LogDebug("this: %llx - Backref: %lld - %s\n", this, nameList.size(), s.c_str());
+	for (const auto& name : nameList)
+		if (name == s)
+			return;
+	nameList.push_back(s);
+}
+
+
+void Demangle::BackrefList::PushFrontStringBackref(string& s)
+{
+	if (s.size() > MAX_DEMANGLE_LENGTH)
+		throw DemangleException();
+	// LogDebug("this: %llx - F-Backref: %lld - %s\n", this, nameList.size(), s.c_str());
+	nameList.insert(nameList.begin(), s);
+}
+
+
+Demangle::Demangle(Architecture* arch, string mangledName) :
+	reader(mangledName),
+	m_arch(arch),
+	m_platform(nullptr),
+	m_view(nullptr)
+{
+	m_logger = LogRegistry::CreateLogger("MSVCDemangle");
+	m_logger->ResetIndent();
+}
+
+
+Demangle::Demangle(Ref<Platform> platform, string mangledName) :
+	reader(mangledName),
+	m_arch(platform->GetArchitecture()),
+	m_platform(platform),
+	m_view(nullptr)
+{
+	m_logger = LogRegistry::CreateLogger("MSVCDemangle");
+	m_logger->ResetIndent();
+}
+
+
+Demangle::Demangle(Ref<BinaryView> view, string mangledName) :
+	reader(mangledName),
+	m_view(view)
+{
+	m_platform = view->GetDefaultPlatform();
+	if (!m_platform)
+		throw DemangleException();
+	m_arch = m_platform->GetArchitecture();
+	m_logger = LogRegistry::CreateLogger("MSVCDemangle");
+	m_logger->ResetIndent();
+}
+
+
+TypeBuilder Demangle::DemangleVarType(BackrefList& varList, bool isReturn, QualifiedName& name)
+{
+	m_logger->LogDebug("%s: '%s' - %lu\n", __FUNCTION__, reader.GetRaw(), varList.nameList.size());
+	TypeBuilder newType;
+	bool _const = false, _volatile = false, isMember = false; //TODO: use this info, _signed = false;
+	BNReferenceType refType;
+	BNTypeClass typeClass = IntegerTypeClass;
+	BNStructureVariant structType;
+	QualifiedName varName;
+	QualifiedName typeName;
+	BNNameType classFunctionType;
+
+	size_t width;
+	char elm = reader.Read();
+	switch (elm)
+	{
+	case 'A':
+		typeClass = PointerTypeClass;
+		refType = ReferenceReferenceType;
+		_const = false;
+		_volatile = false;
+		break;
+	case 'B':
+		typeClass = PointerTypeClass;
+		refType = ReferenceReferenceType;
+		_const = false;
+		_volatile = true;
+		break;
+	case 'C': return TypeBuilder::IntegerType(1, true);
+	case 'D': return TypeBuilder::IntegerType(1, true);
+	case 'E': return TypeBuilder::IntegerType(1, false);
+	case 'F': return TypeBuilder::IntegerType(2, true);
+	case 'G': return TypeBuilder::IntegerType(2, false);
+	case 'H': return TypeBuilder::IntegerType(4, true);
+	case 'I': return TypeBuilder::IntegerType(4, false);
+	case 'J': return TypeBuilder::IntegerType(4, true, "long");
+	case 'K': return TypeBuilder::IntegerType(4, false, "unsigned long");
+	case 'M': return TypeBuilder::FloatType(4);
+	case 'N': return TypeBuilder::FloatType(8);
+	case 'O': return TypeBuilder::FloatType(10, "long double");
+	case 'P': // *
+		typeClass = PointerTypeClass;
+		refType = PointerReferenceType;
+		_const = false;
+		_volatile = false;
+		break;
+	case 'Q': // const *
+		typeClass = PointerTypeClass;
+		refType = PointerReferenceType;
+		_const = true;
+		_volatile = false;
+		break;
+	case 'R': // volatile *
+		typeClass = PointerTypeClass;
+		refType = PointerReferenceType;
+		_const = false;
+		_volatile = true;
+		break;
+	case 'S': // const volatile *
+		typeClass = PointerTypeClass;
+		refType = PointerReferenceType;
+		_const = true;
+		_volatile = true;
+		break;
+	case 'T': typeClass = StructureTypeClass; structType = UnionStructureType;  break;
+	case 'U': typeClass = StructureTypeClass; structType = StructStructureType; break;
+	case 'V': typeClass = StructureTypeClass; structType = ClassStructureType;  break;
+	case 'W':
+		typeClass = EnumerationTypeClass;
+		switch (reader.Read())
+		{
+		case '0': width = 1; /* TODO: use these _signed = true;  */ break;
+		case '1': width = 1; /* TODO: use these _signed = false; */ break;
+		case '2': width = 2; /* TODO: use these _signed = true;  */ break;
+		case '3': width = 2; /* TODO: use these _signed = false; */ break;
+		case '4': width = 4; /* TODO: use these _signed = true;  */ break;
+		case '5': width = 4; /* TODO: use these _signed = false; */ break;
+		case '6': width = 4; /* TODO: use these _signed = true;  */ break;
+		case '7': width = 4; /* TODO: use these _signed = false; */ break;
+		default: throw DemangleException();
+		}
+		break;
+	case 'X': return TypeBuilder::VoidType(); break;
+	case 'Y':
+		throw DemangleException(); //TODO: handle cointerfaces
+	case 'Z': return TypeBuilder::VarArgsType(); break;
+	case '_':
+		switch (reader.Read())
+		{
+		case 'D': newType = TypeBuilder::IntegerType(1, true); break;
+		case 'E': newType = TypeBuilder::IntegerType(1, false); break;
+		case 'F': newType = TypeBuilder::IntegerType(2, true); break;
+		case 'G': newType = TypeBuilder::IntegerType(2, false); break;
+		case 'H': newType = TypeBuilder::IntegerType(4, true); break;
+		case 'I': newType = TypeBuilder::IntegerType(4, false); break;
+		case 'J': newType = TypeBuilder::IntegerType(8, true); break;
+		case 'K': newType = TypeBuilder::IntegerType(8, false); break;
+		case 'L': newType = TypeBuilder::IntegerType(16, true); break;
+		case 'M': newType = TypeBuilder::IntegerType(16, false); break;
+		case 'N': newType = TypeBuilder::BoolType(); break;
+		case 'O':
+		{
+			QualifiedName name;
+			m_logger->Indent();
+			auto childType = DemangleVarType(varList, false, name);
+			m_logger->Dedent();
+			newType = TypeBuilder::ArrayType(childType.Finalize(), 0);
+			break;
+		}
+		case 'S': newType = TypeBuilder::IntegerType(2, true, "char16_t"); break;
+		case 'U': newType = TypeBuilder::IntegerType(4, true, "char32_t"); break;
+		case 'W': newType = TypeBuilder::IntegerType(2, false, "wchar_t"); break;
+		case 'X': typeClass = StructureTypeClass; structType = ClassStructureType; break; //Coclass
+		case 'Y': typeClass = StructureTypeClass; structType = ClassStructureType; break; //Cointerface
+		default:
+			throw DemangleException();
+		}
+		break;
+	case '$':
+		if (reader.PeekString(2) == "$Q") // &&
+		{
+			reader.Consume(2);
+			typeClass = PointerTypeClass;
+			refType = RValueReferenceType;
+			_const = false;
+			_volatile = false;
+		}
+		else if (reader.PeekString(2) == "$R") // && volatile
+		{
+			reader.Consume(2);
+			typeClass = PointerTypeClass;
+			refType = RValueReferenceType;
+			_const = false;
+			_volatile = true;
+		}
+		else if (reader.PeekString(2) == "$A")
+		{
+			reader.Consume(2);
+			char num = reader.Read();
+			if (num == 8)
+				return DemangleFunction(NoNameType, true,  varList);
+			if (num == '6' || num == '7')
+				return DemangleFunction(NoNameType, false, varList);
+			throw DemangleException();
+		}
+		else if (reader.PeekString(2) == "$C")
+		{
+			reader.Consume(2);
+			DemangleModifiers(_const, _volatile, isMember);
+			QualifiedName name;
+			m_logger->Indent();
+			newType = DemangleVarType(varList, false, name);
+			m_logger->Dedent();
+			newType.SetConst(_const);
+			newType.SetVolatile(_volatile);
+			return newType;
+		}
+		else if (reader.PeekString(2) == "$T")
+		{
+			reader.Consume(2);
+			return TypeBuilder::ValueType("std::nullptr");
+		}
+		else if (reader.Peek() == '0')
+		{
+			reader.Consume();
+			int64_t value;
+			DemangleNumber(value);
+			return TypeBuilder::ValueType(to_string(value));
+		}
+		else if (reader.Peek() == '1')
+		{
+			reader.Consume();
+			auto context = DemangleSymbol();
+			return TypeBuilder::PointerType(m_arch, context.type.Finalize());
+		}
+		else
+			throw DemangleException();
+		break;
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+		//Make a copy of the item in the backref list. Exit early since we don't want this added to the backref list.
+		m_logger->LogDebug("Backref %u %lu", elm - '0', varList.typeList.size());
+		return varList.GetTypeBackref(elm - '0');
+	default:
+		throw DemangleException();
+	}
+
+	switch (typeClass)
+	{
+	case PointerTypeClass:
+	{
+		switch (reader.Peek())
+		{
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+			throw DemangleException();
+		case '6':
+		{
+			if (refType != PointerReferenceType) //No references to functions
+			{
+				throw DemangleException();
+			}
+			reader.Consume();
+			auto childType = DemangleFunction(NoNameType, false, varList);
+			newType = TypeBuilder::PointerType(m_arch,
+			                                   childType.Finalize(),
+			                                   _const,
+			                                   _volatile,
+			                                   refType);
+			break;
+		}
+		case '7': //Function pointer
+		case '9': //Class Function pointer
+		{
+			if (refType != PointerReferenceType) //No references to functions
+			{
+				throw DemangleException();
+			}
+			reader.Consume();
+			auto childType = DemangleFunction(NoNameType, true, varList);
+			newType = TypeBuilder::PointerType(m_arch,
+			                                   childType.Finalize(),
+			                                   _const,
+			                                   _volatile,
+			                                   refType);
+			break;
+		}
+		case '8': //Named class function pointer
+		{
+			if (refType != PointerReferenceType) //No references to functions
+			{
+				throw DemangleException();
+			}
+			reader.Consume();
+			DemangleName(name, classFunctionType, varList);
+			name.push_back("");
+			auto childType = DemangleFunction(NoNameType, true, varList);
+			newType = TypeBuilder::PointerType(m_arch,
+			                                   childType.Finalize(),
+			                                   _const,
+			                                   _volatile,
+			                                   refType);
+			break;
+		}
+		default:  // Non-numeric
+		{
+			m_logger->LogDebug("Demangle pointer subtype: '%s'\n", reader.GetRaw());
+			TypeBuilder child;
+			bool _const2 = false, _volatile2 = false, isMember = false;
+			auto suffix = DemanglePointerSuffix();
+			DemangleModifiers(_const2, _volatile2, isMember);
+			if (reader.Peek() == 'Y') //Multi-dimentional array
+			{
+				m_logger->LogDebug("Demangle multi-dimentional array");
+				int64_t nDimentions;
+				reader.Consume();
+				DemangleNumber(nDimentions);
+				vector<uint64_t> elementList;
+				while (nDimentions--)
+				{
+					int64_t element = 0;
+					DemangleNumber(element);
+					elementList.push_back(element);
+				}
+				QualifiedName name;
+				m_logger->Indent();
+				child = DemangleVarType(varList, false, name);
+				m_logger->Dedent();
+
+				for (auto i = elementList.rbegin(); i != elementList.rend(); i++)
+				{
+					child = TypeBuilder::ArrayType(child.Finalize(), *i);
+				}
+			}
+			else
+			{
+				QualifiedName name;
+				m_logger->Indent();
+				child = DemangleVarType(varList, true, name);
+				m_logger->Dedent();
+			}
+
+			child.SetConst(_const2);
+			child.SetVolatile(_volatile2);
+			newType = TypeBuilder::PointerType(m_arch,
+			                                   child.Finalize(),
+			                                   _const,
+			                                   _volatile,
+			                                   refType);
+
+			newType.SetPointerSuffix(suffix);
+			m_logger->LogDebug("Name: %s\n", newType.GetString().c_str());
+			break;
+		}
+		}
+		break;
+	}
+	case EnumerationTypeClass:
+		m_logger->LogDebug("Demangle enumeration\n");
+		m_logger->Indent();
+		DemangleName(typeName, classFunctionType, varList);
+		m_logger->Dedent();
+		newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(EnumNamedTypeClass, typeName),
+		                                 width, width);
+		break;
+	case StructureTypeClass:
+		m_logger->LogDebug("Demangle structure\n");
+		m_logger->Indent();
+		DemangleName(typeName, classFunctionType, varList);
+		m_logger->Dedent();
+		switch (structType)
+		{
+		case ClassStructureType:
+			newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				ClassNamedTypeClass, typeName));
+			break;
+		case StructStructureType:
+			newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				StructNamedTypeClass, typeName));
+			break;
+		case UnionStructureType:
+			newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				UnionNamedTypeClass, typeName));
+			break;
+		default:
+			newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+				UnknownNamedTypeClass, typeName));
+			break;
+		}
+		break;
+	default:
+		break;
+	}
+	if (!isReturn)
+	{
+		varList.PushTypeBackref(newType);
+	}
+	return newType;
+}
+
+
+void Demangle::DemangleNumber(int64_t& num)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	num = 0;
+	int mult = 1;
+	if (reader.Peek() == '?')
+	{
+		mult = -1;
+		reader.Consume();
+	}
+
+	//The number is decimal 1-10
+	if (reader.Peek() >= '0' && reader.Peek() <= '9')
+	{
+		num = mult * (reader.Read() + 1 - '0');
+		return;
+	}
+	else
+	{
+		//The number is hexidecimal
+		string strnum = reader.ReadUntil('@');
+		for (auto a : strnum)
+		{
+			num *= 16;
+			if (a >= 'A' && a <= 'P')
+				num += a - 'A';
+			else
+				throw DemangleException();
+		}
+		num *= mult;
+		return;
+	}
+}
+
+
+void Demangle::DemangleChar(char& ch)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	// Basic char is just the char
+	if (reader.Peek() != '?')
+	{
+		ch = reader.Peek();
+		reader.Consume();
+		return;
+	}
+	reader.Consume();
+
+	// Hex char is ?$XX for 2 hex digits XX
+	if (reader.Peek() == '$')
+	{
+		m_logger->LogDebug("%s: Hex digit '%s'\n", __FUNCTION__, reader.GetRaw());
+
+		reader.Consume();
+		char c1 = reader.Peek();
+		reader.Consume();
+		char c2 = reader.Peek();
+		reader.Consume();
+
+		if (c1 < 'A' || c1 > 'P')
+			throw DemangleException("Invalid character");
+		if (c2 < 'A' || c2 > 'P')
+			throw DemangleException("Invalid character");
+
+		uint8_t b1 = c1 - 'A';
+		uint8_t b2 = c2 - 'A';
+
+		ch = (char)((b1 << 4) | b2);
+		return;
+	}
+
+	m_logger->LogDebug("%s: Table lookup '%s'\n", __FUNCTION__, reader.GetRaw());
+
+	// Otherwise it's a lookup based on some big table
+	// Thanks, LLVM!
+	switch (reader.Peek())
+	{
+	case '0': ch = ','; reader.Consume(); return;
+	case '1': ch = '/'; reader.Consume(); return;
+	case '2': ch = '\\'; reader.Consume(); return;
+	case '3': ch = ':'; reader.Consume(); return;
+	case '4': ch = '.'; reader.Consume(); return;
+	case '5': ch = ' '; reader.Consume(); return;
+	case '6': ch = '\n'; reader.Consume(); return;
+	case '7': ch = '\t'; reader.Consume(); return;
+	case '8': ch = '\''; reader.Consume(); return;
+	case '9': ch = '-'; reader.Consume(); return;
+	case 'a': ch = '\xE1'; reader.Consume(); return;
+	case 'b': ch = '\xE2'; reader.Consume(); return;
+	case 'c': ch = '\xE3'; reader.Consume(); return;
+	case 'd': ch = '\xE4'; reader.Consume(); return;
+	case 'e': ch = '\xE5'; reader.Consume(); return;
+	case 'f': ch = '\xE6'; reader.Consume(); return;
+	case 'g': ch = '\xE7'; reader.Consume(); return;
+	case 'h': ch = '\xE8'; reader.Consume(); return;
+	case 'i': ch = '\xE9'; reader.Consume(); return;
+	case 'j': ch = '\xEA'; reader.Consume(); return;
+	case 'k': ch = '\xEB'; reader.Consume(); return;
+	case 'l': ch = '\xEC'; reader.Consume(); return;
+	case 'm': ch = '\xED'; reader.Consume(); return;
+	case 'n': ch = '\xEE'; reader.Consume(); return;
+	case 'o': ch = '\xEF'; reader.Consume(); return;
+	case 'p': ch = '\xF0'; reader.Consume(); return;
+	case 'q': ch = '\xF1'; reader.Consume(); return;
+	case 'r': ch = '\xF2'; reader.Consume(); return;
+	case 's': ch = '\xF3'; reader.Consume(); return;
+	case 't': ch = '\xF4'; reader.Consume(); return;
+	case 'u': ch = '\xF5'; reader.Consume(); return;
+	case 'v': ch = '\xF6'; reader.Consume(); return;
+	case 'w': ch = '\xF7'; reader.Consume(); return;
+	case 'x': ch = '\xF8'; reader.Consume(); return;
+	case 'y': ch = '\xF9'; reader.Consume(); return;
+	case 'z': ch = '\xFA'; reader.Consume(); return;
+	case 'A': ch = '\xC1'; reader.Consume(); return;
+	case 'B': ch = '\xC2'; reader.Consume(); return;
+	case 'C': ch = '\xC3'; reader.Consume(); return;
+	case 'D': ch = '\xC4'; reader.Consume(); return;
+	case 'E': ch = '\xC5'; reader.Consume(); return;
+	case 'F': ch = '\xC6'; reader.Consume(); return;
+	case 'G': ch = '\xC7'; reader.Consume(); return;
+	case 'H': ch = '\xC8'; reader.Consume(); return;
+	case 'I': ch = '\xC9'; reader.Consume(); return;
+	case 'J': ch = '\xCA'; reader.Consume(); return;
+	case 'K': ch = '\xCB'; reader.Consume(); return;
+	case 'L': ch = '\xCC'; reader.Consume(); return;
+	case 'M': ch = '\xCD'; reader.Consume(); return;
+	case 'N': ch = '\xCE'; reader.Consume(); return;
+	case 'O': ch = '\xCF'; reader.Consume(); return;
+	case 'P': ch = '\xD0'; reader.Consume(); return;
+	case 'Q': ch = '\xD1'; reader.Consume(); return;
+	case 'R': ch = '\xD2'; reader.Consume(); return;
+	case 'S': ch = '\xD3'; reader.Consume(); return;
+	case 'T': ch = '\xD4'; reader.Consume(); return;
+	case 'U': ch = '\xD5'; reader.Consume(); return;
+	case 'V': ch = '\xD6'; reader.Consume(); return;
+	case 'W': ch = '\xD7'; reader.Consume(); return;
+	case 'X': ch = '\xD8'; reader.Consume(); return;
+	case 'Y': ch = '\xD9'; reader.Consume(); return;
+	case 'Z': ch = '\xDA'; reader.Consume(); return;
+	default:
+		throw DemangleException("Unknown character");
+	}
+}
+
+
+void Demangle::DemangleWideChar(uint16_t& wch)
+{
+	char c1, c2;
+	DemangleChar(c1);
+	DemangleChar(c2);
+
+	wch = (uint16_t)(((uint16_t)c1 << 8) | (uint16_t)c2);
+}
+
+
+void Demangle::DemangleVariableList(vector<FunctionParameter>& paramList, BackrefList& varList)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	bool _const = false, _volatile = false, isMember = false;
+	set<BNPointerSuffix> suffix;
+	for (size_t i = 0; reader.Peek() != 'Z'; i++)
+	{
+		bool hasModifiers = false;
+		if (reader.Peek() == '@')
+		{
+			reader.Consume();
+			break;
+		}
+		else if (reader.Peek() == '?')
+		{
+			reader.Consume();
+			suffix = DemanglePointerSuffix();
+			DemangleModifiers(_const, _volatile, isMember);
+			hasModifiers = true;
+		}
+
+		FunctionParameter vt;
+		QualifiedName name;
+		m_logger->LogDebug("Argument %d: %s", i, reader.GetRaw());
+		m_logger->Indent();
+		TypeBuilder type = DemangleVarType(varList, false, name);
+		m_logger->Dedent();
+		if (hasModifiers)
+		{
+			type.SetConst(_const);
+			type.SetVolatile(_volatile);
+			type.SetPointerSuffix(suffix);
+		}
+		vt.name = name.GetString();
+		vt.type = type.Finalize();
+		vt.defaultLocation = true;
+
+		paramList.push_back(vt);
+		m_logger->LogDebug("Argument %zu: '%s' - '%s'\n", i, vt.type->GetString().c_str(), reader.GetRaw());
+	}
+	if (reader.Peek() == 'Z')
+		reader.Consume();
+	m_logger->LogDebug("%s: done '%s'\n", __FUNCTION__, reader.GetRaw());
+}
+
+
+Demangle::NameType Demangle::GetNameType()
+{
+	if (reader.Peek() == '?')
+	{
+		reader.Consume();
+		if (reader.Peek()== '?')
+		{
+			reader.Consume();
+			return GetNameType();
+		}
+		else if (reader.Peek() == '$')
+		{
+			reader.Consume();
+			return NameTemplate;
+		}
+		else if (reader.Peek() == '0')
+		{
+			reader.Consume();
+			return NameConstructor;
+		}
+		else if (reader.Peek() == '1')
+		{
+			reader.Consume();
+			return NameDestructor;
+		}
+		else if (reader.Peek() == 'B')
+		{
+			reader.Consume();
+			return NameReturn;
+		}
+		else if (reader.PeekString(2) == "_R")
+		{
+			reader.Consume(2);
+			return NameRtti;
+		}
+			// else if (reader.PeekString(3) == "__E")
+			// {
+			// 	reader.Consume(2);
+			// 	return NameDynamicInitializer;
+			// }
+		else
+		{
+			return NameLookup;
+		}
+	}
+	else if (reader.Peek() >= '0' && reader.Peek() <= '9')
+	{
+		return NameBackref;
+	}
+	return NameString;
+}
+
+
+void Demangle::DemangleNameTypeString(string& out)
+{
+	out = reader.ReadUntil('@');
+}
+
+
+void Demangle::DemangleNameTypeRtti(BNNameType& classFunctionType,
+                                    BackrefList& nameBackrefList,
+                                    string& out)
+{
+	TypeBuilder rtti;
+	switch (reader.Read())
+	{
+	case '0':
+	{
+		if (reader.Peek() != '?')
+			throw DemangleException();
+		reader.Consume();
+
+		bool _const = false, _volatile = false, isMember = false;
+		auto suffix = DemanglePointerSuffix();
+		DemangleModifiers(_const, _volatile, isMember);
+
+		QualifiedName name;
+		m_logger->Indent();
+		rtti = DemangleVarType(nameBackrefList, false, name);
+		m_logger->Dedent();
+		rtti.SetConst(_const);
+		rtti.SetVolatile(_volatile);
+		rtti.SetPointerSuffix(suffix);
+		out = rtti.GetString() + " `RTTI Type Descriptor' ";
+		classFunctionType = RttiTypeDescriptor;
+		break;
+	}
+	case '1':
+		out = "`RTTI Base Class Descriptor at (";
+		for (int i = 0; i < 4; i++)
+		{
+			int64_t num = 0;
+			DemangleNumber(num);
+			if (i > 0)
+			{
+				out += ",";
+			}
+			out += to_string(num);
+		}
+		out += ")'";
+		classFunctionType = RttiBaseClassDescriptor;
+		break;
+	case '2':
+		out = "`RTTI Base Class Array'";
+		classFunctionType = RttiBaseClassArray;
+		break;
+	case '3':
+		out = "`RTTI Class Hierarchy Descriptor'";
+		classFunctionType = RttiClassHierarchyDescriptor;
+		break;
+	case '4':
+		out = "`RTTI Complete Object Locator'";
+		classFunctionType = RttiCompleteObjectLocator;
+		break;
+	default: throw DemangleException();
+	}
+}
+
+
+void Demangle::DemangleTypeNameLookup(string& out, BNNameType& functionType)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	switch (reader.Read())
+	{
+	case '?': functionType = NoNameType; break;
+	case '2': functionType = OperatorNewNameType; break;
+	case '3': functionType = OperatorDeleteNameType; break;
+	case '4': functionType = OperatorAssignNameType; break;
+	case '5': functionType = OperatorRightShiftNameType; break;
+	case '6': functionType = OperatorLeftShiftNameType; break;
+	case '7': functionType = OperatorNotNameType; break;
+	case '8': functionType = OperatorEqualNameType; break;
+	case '9': functionType = OperatorNotEqualNameType; break;
+	case 'A': functionType = OperatorArrayNameType; break;
+	case 'C': functionType = OperatorArrowNameType; break;
+	case 'D': functionType = OperatorStarNameType; break;
+	case 'E': functionType = OperatorIncrementNameType; break;
+	case 'F': functionType = OperatorDecrementNameType; break;
+	case 'G': functionType = OperatorMinusNameType; break;
+	case 'H': functionType = OperatorPlusNameType; break;
+	case 'I': functionType = OperatorBitAndNameType; break;
+	case 'J': functionType = OperatorArrowStarNameType; break;
+	case 'K': functionType = OperatorDivideNameType; break;
+	case 'L': functionType = OperatorModulusNameType; break;
+	case 'M': functionType = OperatorLessThanNameType; break;
+	case 'N': functionType = OperatorLessThanEqualNameType; break;
+	case 'O': functionType = OperatorGreaterThanNameType; break;
+	case 'P': functionType = OperatorGreaterThanEqualNameType; break;
+	case 'Q': functionType = OperatorCommaNameType; break;
+	case 'R': functionType = OperatorParenthesesNameType; break;
+	case 'S': functionType = OperatorTildeNameType; break;
+	case 'T': functionType = OperatorXorNameType; break;
+	case 'U': functionType = OperatorBitOrNameType; break;
+	case 'V': functionType = OperatorLogicalAndNameType; break;
+	case 'W': functionType = OperatorLogicalOrNameType; break;
+	case 'X': functionType = OperatorStarEqualNameType; break;
+	case 'Y': functionType = OperatorPlusEqualNameType; break;
+	case 'Z': functionType = OperatorMinusEqualNameType; break;
+	case '_':
+	{
+		m_logger->LogDebug(" %s: '%s'\n", __FUNCTION__, reader.GetRaw());
+		switch (reader.Read())
+		{
+		case '0': functionType = OperatorDivideEqualNameType; break;
+		case '1': functionType = OperatorModulusEqualNameType; break;
+		case '2': functionType = OperatorRightShiftEqualNameType; break;
+		case '3': functionType = OperatorLeftShiftEqualNameType; break;
+		case '4': functionType = OperatorAndEqualNameType; break;
+		case '5': functionType = OperatorOrEqualNameType; break;
+		case '6': functionType = OperatorXorEqualNameType; break;
+		case '7': functionType = VFTableNameType; break;
+		case '8': functionType = VBTableNameType; break;
+		case '9': functionType = VCallNameType; break;
+		case 'A': functionType = TypeofNameType; break;
+		case 'B': functionType = LocalStaticGuardNameType; break;
+		case 'C': functionType = StringNameType; break;
+		case 'D': functionType = VBaseDestructorNameType; break;
+		case 'E': functionType = VectorDeletingDestructorNameType; break;
+		case 'F': functionType = DefaultConstructorClosureNameType; break;
+		case 'G': functionType = ScalarDeletingDestructorNameType; break;
+		case 'H': functionType = VectorConstructorIteratorNameType; break;
+		case 'I': functionType = VectorDestructorIteratorNameType; break;
+		case 'J': functionType = VectorVBaseConstructorIteratorNameType; break;
+		case 'K': functionType = VirtualDisplacementMapNameType; break;
+		case 'L': functionType = EHVectorConstructorIteratorNameType; break;
+		case 'M': functionType = EHVectorDestructorIteratorNameType; break;
+		case 'N': functionType = EHVectorVBaseConstructorIteratorNameType; break;
+		case 'O': functionType = CopyConstructorClosureNameType; break;
+		case 'P': functionType = UDTReturningNameType; break;
+		case 'S': functionType = LocalVFTableNameType; break;
+		case 'T': functionType = LocalVFTableConstructorClosureNameType; break;
+		case 'U': functionType = OperatorNewArrayNameType; break;
+		case 'V': functionType = OperatorDeleteArrayNameType; break;
+		case 'X': functionType = PlacementDeleteClosureNameType; break;
+		case 'Y': functionType = PlacementDeleteClosureArrayNameType; break;
+		case 'Q': // Fallthrough
+		case 'W': // Fallthrough
+		case 'Z': functionType = NoNameType; break;
+		case '_':
+			m_logger->LogDebug("  %s: '%s'\n", __FUNCTION__, reader.GetRaw());
+			switch (reader.Read())
+			{
+			case 'A': functionType = ManagedVectorConstructorIteratorNameType; break;
+			case 'B': functionType = ManagedVectorDestructorIteratorNameType; break;
+			case 'C': functionType = EHVectorCopyConstructorIteratorNameType; break;
+			case 'D': functionType = EHVectorVBaseConstructorIteratorNameType; break;
+			case 'E': functionType = DynamicInitializerNameType; break;
+			case 'F': functionType = DynamicAtExitDestructorNameType; break;
+			case 'G': functionType = VectorCopyConstructorIteratorNameType; break;
+			case 'H': functionType = VectorVBaseCopyConstructorIteratorNameType; break;
+			case 'I': functionType = ManagedVectorCopyConstructorIteratorNameType; break;
+			case 'J': functionType = LocalStaticGuardNameType; break;
+			case 'K': functionType = UserDefinedLiteralOperatorNameType; break;
+			default: throw DemangleException("Demangle Lookup Failed"); // fall through
+			}
+			break;
+		default:
+			throw DemangleException("Demangle Lookup Failed");
+		}
+		break;
+	}
+	default: throw DemangleException("Demangle Lookup Failed");
+	}
+	out = Type::GetNameTypeString(functionType);
+}
+
+
+string Demangle::DemangleTemplateInstantiationName(BackrefList& nameBackrefList)
+{
+	string out;
+	BackrefList templateBackref;
+	reader.Consume(2);
+	m_logger->LogDebug("DemangleTemplateInstantiationName: '%s'\n", reader.GetRaw());
+	if (reader.Peek() >= '0' && reader.Peek() <= '9')
+	{
+		out = nameBackrefList.GetStringBackref(reader.Read() - '0');
+	}
+	else
+	{
+		DemangleNameTypeString(out);
+	}
+	nameBackrefList.PushStringBackref(out);
+	return out;
+}
+
+
+string Demangle::DemangleTemplateParams(vector<FunctionParameter>& params, BackrefList& nameBackrefList, string& out)
+{
+	m_logger->Indent();
+	DemangleVariableList(params, nameBackrefList);
+	m_logger->Dedent();
+	m_logger->LogDebug("VariableList done\n");
+	out += "<";
+	for (size_t i = 0; i < params.size(); i++)
+	{
+		if (i == 0)
+		{
+			out += params[i].type->GetString();
+		}
+		else
+		{
+			out += "," + params[i].type->GetString();
+		}
+	}
+	if (out[out.size()-1] == '>')
+		out += " "; //Be c++03 compliant where we can
+	out += ">";
+
+	nameBackrefList.PushStringBackref(out);
+	return out;
+}
+
+// void Demangle::DemangleInitFiniStub(bool destructor, QualifiedName& nameList, BackrefList& nameBackrefList, BNNameType& classFunctionType)
+// {
+// 	bool isStatic = false;
+// 	if (reader.Peek() == '?')
+// 	{
+// 		reader.Consume();
+// 		isStatic = true;
+// 	}
+// 	string out = DemangleUnqualifiedSymbolName(nameList, nameBackrefList, classFunctionType);
+// }
+
+
+string Demangle::DemangleUnqualifiedSymbolName(QualifiedName& nameList, BackrefList& nameBackrefList, BNNameType& classFunctionType)
+{
+	string out;
+	if (reader.PeekString(2) == "?$")
+	{
+		reader.Consume(2);
+		out = DemangleTemplateInstantiationName(nameBackrefList);
+		nameList.insert(nameList.begin(), out);
+	}
+	else if (reader.Peek() == '?')
+	{
+		reader.Consume();
+		DemangleTypeNameLookup(out, classFunctionType);
+	}
+	else if (reader.Peek() >= '0' && reader.Peek() <= '9')
+	{
+		out = nameBackrefList.GetStringBackref(reader.Read() - '0');
+	}
+	else
+	{
+		DemangleNameTypeString(out);
+	}
+	return out;
+}
+
+
+TypeBuilder Demangle::DemangleString()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	// ??_C@_<length><crc32>@<name>
+	if (reader.Peek() != '_')
+	{
+		throw DemangleException("Invalid mangled string name");
+	}
+	reader.Consume();
+
+	// Wide char flag (1 yes / 0 no)
+	bool isWideChar = false;
+	switch (reader.Peek())
+	{
+	case '1':
+		isWideChar = true;
+		break;
+	case '0':
+		break;
+	default:
+		throw DemangleException("Invalid mangled string name");
+	}
+	reader.Consume();
+
+	// Length is just a number
+
+	int64_t lengthRaw;
+	DemangleNumber(lengthRaw);
+	if (lengthRaw < 0)
+	{
+		throw DemangleException("Invalid mangled string name");
+	}
+	uint64_t length = (uint64_t)lengthRaw;
+
+	m_logger->LogDebug("%s: Before CRC32 '%s'\n", __FUNCTION__, reader.GetRaw());
+
+	// CRC32 (ignored)
+	while (reader.Peek() != '@')
+	{
+		// Usually 8 bytes but I've seen it be 7 for some ungodly reason
+		reader.Consume();
+	}
+
+	reader.Consume();
+
+	bool truncated = false;
+	string name = "";
+	TypeBuilder type;
+
+	// String bytes
+	if (isWideChar)
+	{
+		m_logger->LogDebug("%s: Wide string '%s'\n", __FUNCTION__, reader.GetRaw());
+		string utf8name;
+		truncated = (length > 64);
+		while (reader.Peek() != '@')
+		{
+			uint16_t wch;
+			DemangleWideChar(wch);
+
+			uint8_t chs[2];
+			chs[0] = wch & 0xFF;
+			chs[1] = wch >> 8;
+
+			// TODO: This is actually UCS2 but we don't have an easy decoder for that
+			utf8name += Unicode::UTF16ToUTF8(&chs[0], 2);
+		}
+		reader.Consume();
+
+		name = Unicode::ToEscapedString(Unicode::GetBlocksForNames({}), false, utf8name.data(), utf8name.size());
+		type = Type::ArrayType(Type::WideCharType(2), length / 2);
+	}
+	else
+	{
+		m_logger->LogDebug("%s: Non-wide string '%s'\n", __FUNCTION__, reader.GetRaw());
+		uint64_t numNulls = 0;
+		size_t endNulls = 0;
+		vector<uint8_t> chars;
+		while (reader.Peek() != '@')
+		{
+			char ch;
+			DemangleChar(ch);
+			if (ch == 0)
+			{
+				numNulls++;
+				endNulls++;
+			}
+			else
+			{
+				endNulls = 0;
+			}
+			chars.push_back(ch);
+		}
+		reader.Consume();
+
+		if (length > (uint64_t)chars.size() + 1)
+		{
+			truncated = true;
+		}
+
+		// Now time to guess encoding
+		if (chars.size() % 1 != 0)
+		{
+			m_logger->LogDebug("%s: Looks like UTF8 '%s'\n", __FUNCTION__, reader.GetRaw());
+			name = Unicode::ToEscapedString(Unicode::GetBlocksForNames({}), false, chars.data(), chars.size() - endNulls);
+			type = Type::ArrayType(Type::IntegerType(1, true), length);
+		}
+		else
+		{
+			if (chars.size() % 4 == 0 && numNulls > length * 2 / 3)
+			{
+				m_logger->LogDebug("%s: Looks like UTF32 '%s'\n", __FUNCTION__, reader.GetRaw());
+				string utf8name;
+				for (size_t i = 0; i < chars.size() - endNulls; i += 4)
+				{
+					utf8name += Unicode::UTF32ToUTF8(chars.data() + i);
+				}
+				name = Unicode::ToEscapedString(Unicode::GetBlocksForNames({}), false, utf8name.data(), utf8name.size());
+				type = Type::ArrayType(Type::WideCharType(4), length / 4);
+			}
+			else if (numNulls > length / 3)
+			{
+				m_logger->LogDebug("%s: Looks like UTF16 '%s'\n", __FUNCTION__, reader.GetRaw());
+				string utf8name;
+				for (size_t i = 0; i < chars.size() - endNulls; i += 2)
+				{
+					utf8name += Unicode::UTF16ToUTF8(chars.data() + i, 2);
+				}
+				name = Unicode::ToEscapedString(Unicode::GetBlocksForNames({}), false, utf8name.data(), utf8name.size());
+				type = Type::ArrayType(Type::WideCharType(2), length / 2);
+			}
+			else
+			{
+				m_logger->LogDebug("%s: Looks like UTF8 '%s'\n", __FUNCTION__, reader.GetRaw());
+
+				name = Unicode::ToEscapedString(Unicode::GetBlocksForNames({}), false, chars.data(), chars.size() - endNulls);
+				type = Type::ArrayType(Type::IntegerType(1, true), length);
+			}
+		}
+	}
+	if (truncated)
+	{
+		name += "...";
+	}
+	m_varName.push_back(name);
+	return type;
+}
+
+
+TypeBuilder Demangle::DemangleTypeInfoName()
+{
+	if (reader.Read() != '?')
+		throw DemangleException("Unknown raw name type");
+	bool _const = false;
+	bool _volatile = false;
+	bool isMember = false;
+	DemangleModifiers(_const, _volatile, isMember);
+
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+
+	QualifiedName name;
+	TypeBuilder type = DemangleVarType(m_backrefList, false, name);
+	type.SetConst(_const);
+	type.SetVolatile(_volatile);
+
+	switch (type.GetClass())
+	{
+	case NamedTypeReferenceClass:
+		m_varName = type.GetNamedTypeReference()->GetName();
+		return type;
+	default:
+		throw DemangleException("Unexpected type of RTTI Type Name");
+	}
+}
+
+
+void Demangle::DemangleName(QualifiedName& nameList,
+                            BNNameType& classFunctionType,
+                            BackrefList& nameBackrefList)
+{
+	string out;
+	BNNameType functionType;
+	BNNameType dummyFunctionType;
+	vector<FunctionParameter> params;
+	while(1)
+	{
+		m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+		switch (GetNameType())
+		{
+		case NameString:
+			m_logger->LogDebug("Demangle String\n");
+			DemangleNameTypeString(out);
+			nameList.insert(nameList.begin(), out);
+			m_logger->LogDebug("Pushing backref NameString %s", out.c_str());
+			nameBackrefList.PushStringBackref(out);
+			m_logger->LogDebug("nameList.front(): %s\n", nameList.front().c_str());
+			m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+			break;
+		case NameLookup:
+			m_logger->LogDebug("Demangle Lookup\n");
+			DemangleTypeNameLookup(out, functionType);
+			classFunctionType = functionType;
+			nameList.insert(nameList.begin(), out);
+			break;
+		case NameBackref:
+			m_logger->LogDebug("Demangle Backref");
+			out = nameBackrefList.GetStringBackref(reader.Read() - '0');
+			m_logger->LogDebug("Demangle Backref: %s", out.c_str());
+			nameList.insert(nameList.begin(), out);
+			break;
+		case NameTemplate:
+		{
+			m_logger->LogDebug("Demangle Template: '%s'\n", reader.GetRaw());
+			BackrefList templateBackref;
+			out = DemangleUnqualifiedSymbolName(nameList, templateBackref, functionType);
+			m_logger->LogDebug("Pushing backref NameTemplate %s", out.c_str());
+			templateBackref.PushStringBackref(out);
+			m_logger->LogDebug("Demangling Template variables %s\n", reader.GetRaw());
+			DemangleTemplateParams(params, templateBackref, out);
+			nameList.insert(nameList.begin(), out);
+			nameBackrefList.PushStringBackref(out);
+			break;
+		}
+		case NameConstructor:
+			m_logger->LogDebug("NameConstructor\n");
+			classFunctionType = ConstructorNameType;
+			DemangleName(nameList, dummyFunctionType, nameBackrefList);
+			if (nameList.size() == 0)
+				throw DemangleException();
+			nameList.push_back(nameList[nameList.size()-1]);
+			return;
+		case NameDestructor:
+			classFunctionType = ConstructorNameType;
+			m_logger->LogDebug("NameDestructor\n");
+			DemangleName(nameList, dummyFunctionType, nameBackrefList);
+			if (nameList.size() == 0)
+				throw DemangleException();
+			nameList.push_back("~" + nameList[nameList.size()-1]);
+			return;
+		case NameRtti:
+			m_logger->LogDebug("NameRtti\n");
+			DemangleNameTypeRtti(classFunctionType, nameBackrefList, out);
+			nameList.insert(nameList.begin(), out);
+			break;
+			// case NameDynamicInitializer:
+			// 	m_logger->LogDebug("NameDynamicInitializer\n");
+			// 	DemangleInitFiniStub(false);
+			// 	break;
+			// case NameDynamicAtExitDestructor:
+			// 	m_logger->LogDebug("NameDynamicAtExitDestructor\n");
+			// 	DemangleInitFiniStub(false);
+			// 	break;
+		case NameReturn:
+			m_logger->LogDebug("NameReturn\n");
+			classFunctionType = OperatorReturnTypeNameType;
+			if (reader.PeekString(2) == "?$")
+			{
+				out = DemangleTemplateInstantiationName(nameBackrefList);
+				DemangleTemplateParams(params, nameBackrefList, out);
+			}
+			else
+			{
+				DemangleNameTypeString(out);
+				nameBackrefList.PushStringBackref(out);
+			}
+			nameList.insert(nameList.begin(), out);
+			break;
+		default:
+			throw DemangleException();
+		}
+		if (nameList.StringSize() > MAX_DEMANGLE_LENGTH)
+			throw DemangleException();
+		if (reader.Peek() == '@')
+		{
+			reader.Consume();
+			return;
+		}
+	}
+}
+
+Ref<CallingConvention> Demangle::GetCallingConventionForType(BNCallingConventionName ccName)
+{
+	string name;
+	switch (ccName)
+	{
+	case NoCallingConvention: name = ""; break;
+	case CdeclCallingConvention: name = "cdecl"; break;
+	case PascalCallingConvention: name = "pascal"; break;
+	case ThisCallCallingConvention: name = "thiscall"; break;
+	case STDCallCallingConvention: name = "stdcall"; break;
+	case FastcallCallingConvention: name = "fastcall"; break;
+	case CLRCallCallingConvention: name = "clrcall"; break;
+	case EabiCallCallingConvention: name = "eabi"; break;
+	case VectorCallCallingConvention: name = "vectorcall"; break;
+	case SwiftCallingConvention: name = "swiftcall"; break;
+	case SwiftAsyncCallingConvention: name = "swiftasync"; break;
+	default: break;
+	}
+
+	if (m_platform)
+	{
+		for (const auto& cc : m_platform->GetCallingConventions())
+		{
+			if (cc->GetName() == name)
+				return cc;
+		}
+	}
+
+	for (const auto& cc : m_arch->GetCallingConventions())
+	{
+		if (cc->GetName() == name)
+			return cc;
+	}
+	return nullptr;
+}
+
+BNCallingConventionName Demangle::DemangleCallingConvention()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	switch (reader.Read())
+	{
+	case 'A': //Exported function
+	case 'B': return CdeclCallingConvention;
+	case 'C': //Exported function
+	case 'D': return PascalCallingConvention;
+	case 'E': //Exported function
+	case 'F': return ThisCallCallingConvention;
+	case 'G': //Exported function
+	case 'H': return STDCallCallingConvention;
+	case 'I': //Exported function
+	case 'J': return FastcallCallingConvention;
+	case 'K': //Exported function
+	case 'L': return NoCallingConvention;
+	case 'M': //Exported function
+	case 'N': return CLRCallCallingConvention;
+	case 'O': //Exported function
+	case 'P': return EabiCallCallingConvention;
+	case 'Q': return VectorCallCallingConvention;
+	case 'S': return SwiftCallingConvention;
+	case 'W': return SwiftAsyncCallingConvention;
+	default:throw DemangleException();
+	}
+}
+
+set<BNPointerSuffix> Demangle::DemanglePointerSuffix()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	set<BNPointerSuffix> suffix;
+	if (reader.Peek() == '@')
+		return suffix;
+
+	char elm = reader.Peek();
+	for (int i = 0; i < 5; i++, elm = reader.Peek())
+	{
+		if (elm == 'E')
+			suffix.insert(suffix.end(), Ptr64Suffix);
+		else if (elm == 'F')
+			suffix.insert(suffix.end(), UnalignedSuffix);
+		else if (elm == 'G')
+			suffix.insert(suffix.end(), ReferenceSuffix);
+		else if (elm == 'H')
+			suffix.insert(suffix.end(), LvalueSuffix);
+		else if (elm == 'I')
+			suffix.insert(suffix.end(), RestrictSuffix);
+		else
+			break;
+		reader.Consume(1);
+	}
+	return suffix;
+}
+
+void Demangle::DemangleModifiers(bool& _const, bool& _volatile, bool &isMember)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	if (reader.Peek() == '@')
+		return;
+
+	_const = false;
+	_volatile = false;
+	isMember = false;
+	char elm = reader.Read();
+	switch (elm)
+	{
+	case 'A': break;
+	case 'B': _const = true; break;
+	case 'J': _const = true; break;
+	case 'C': _volatile = true; break;
+	case 'G': _volatile = true; break;
+	case 'K': _volatile = true; break;
+	case 'D': _const = true; _volatile = true; break;
+	case 'H': _const = true; _volatile = true; break;
+	case 'L': _const = true; _volatile = true; break;
+	case '6': break;
+	case '7': break;
+	case 'M': break;
+	case 'N': break;
+	case 'O': _volatile = true; break;
+	case 'P': _volatile = true; _const = true; break;
+	case 'Q': isMember = true; break;
+	case 'U': break;
+	case 'Y': break;
+	case 'R': _const = true; isMember = true; break;
+	case 'V': _const = true; break;
+	case 'Z': _const = true; break;
+	case 'S': _volatile = true; isMember = true; break;
+	case 'W': _volatile = true; break;
+	case '0': _volatile = true; break;
+	case 'T': _const = true; _volatile = true; isMember = true; break;
+	case 'X': _const = true; _volatile = true; break;
+	case '1': _const = true; _volatile = true; break;
+	case '8': break;
+	case '9': break;
+	case '2': break;
+	case '3': _const = true; break;
+	case '4': _volatile = true; break;
+	case '5': _const = true; _volatile = true; break;
+	case '_':
+		elm = reader.Read();
+		if (elm == 'A' || elm == 'B')
+		{
+			//For unhandled "member" and "based" parameters
+			break;
+		}
+		else if (elm == 'C' || elm == 'D')
+		{
+			//For unhandled "member" and "based" parameters
+			break;
+		}
+		else
+		{
+			throw DemangleException();
+		}
+		break;
+	default: throw DemangleException();
+	}
+	return;
+}
+
+
+TypeBuilder Demangle::DemangleFunction(BNNameType classFunctionType, bool pointerSuffix, BackrefList& nameBackrefList, int funcClass)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	bool _const = false, _volatile = false, isMember = false;
+	set<BNPointerSuffix> suffix;
+	TypeBuilder returnType;
+	BNCallingConventionName cc;
+
+	//Demangle adjustor which we don't do anything with for now
+	if ((funcClass & StaticThunkFunctionClass) == StaticThunkFunctionClass)
+	{
+		int64_t adjustor;
+		DemangleNumber(adjustor);
+		m_varName.back() += "`adjustor{" + to_string(adjustor) + "}'";
+	}
+	else if ((funcClass & VirtualThunkFunctionClass) == VirtualThunkFunctionClass)
+	{
+		if ((funcClass & VirtualThunkExFunctionClass) == VirtualThunkExFunctionClass)
+		{
+			int64_t vbptrOffset;
+			int64_t vbOffsetOffset;
+			int64_t vtorDispOffset;
+			int64_t staticOffset;
+			DemangleNumber(vbptrOffset);
+			DemangleNumber(vbOffsetOffset);
+			DemangleNumber(vtorDispOffset);
+			DemangleNumber(staticOffset);
+			m_varName.back() += "`vtordispex{" + to_string(vbptrOffset) + ", " + to_string(vbOffsetOffset) + ", " + to_string(vtorDispOffset) + ", " + to_string(staticOffset) + "}'";
+		}
+		else
+		{
+			int64_t vtorDispOffset;
+			int64_t staticOffset;
+			DemangleNumber(vtorDispOffset);
+			DemangleNumber(staticOffset);
+			m_varName.back() += "`vtordisp{" + to_string(vtorDispOffset) + ", " + to_string(staticOffset) + "}'";
+		}
+	}
+
+	if (pointerSuffix)
+	{
+		suffix = DemanglePointerSuffix();
+		DemangleModifiers(_const, _volatile, isMember);
+	}
+	if (reader.Peek() == '?')
+		reader.Consume();
+	cc = DemangleCallingConvention();
+	bool shouldHaveReturnType = true;
+	if (reader.Peek() == '@')
+	{
+		//No return type
+		shouldHaveReturnType = false;
+		reader.Consume();
+		m_logger->LogDebug("Function has no return type %s", reader.GetRaw());
+	}
+	else
+	{
+		//Demangle function return type
+		bool return_const = false, return_volatile = false, isMember = false;
+		set<BNPointerSuffix> return_suffix;
+		bool hasModifiers = false;
+		//Check for modifiers before return type
+		if (reader.Peek() == '?')
+		{
+			reader.Consume(1);
+			return_suffix = DemanglePointerSuffix();
+			DemangleModifiers(return_const, return_volatile, isMember);
+			hasModifiers = true;
+		}
+
+		QualifiedName name;
+		m_logger->LogDebug("Demangle function return type %s", reader.GetRaw());
+		m_logger->Indent();
+		returnType = DemangleVarType(nameBackrefList, true, name);
+		m_logger->LogDebug("Return type: %s", returnType.GetString().c_str());
+		m_logger->Dedent();
+		if (hasModifiers)
+		{
+			returnType.SetConst(return_const);
+			returnType.SetVolatile(return_volatile);
+			returnType.SetPointerSuffix(return_suffix);
+		}
+	}
+	if (reader.Peek() == '@')
+		reader.Consume();
+
+	m_logger->LogDebug("\tDemangle Function Parameters %s", reader.GetRaw());
+	vector<FunctionParameter> params;
+	bool needsThisPtr = false;
+	if (cc == ThisCallCallingConvention)
+	{
+		needsThisPtr = true;
+	}
+	if (funcClass != NoneFunctionClass)
+	{
+		if ((funcClass & VirtualFunctionClass) == VirtualFunctionClass
+		    || (funcClass & StaticThunkFunctionClass) == StaticThunkFunctionClass
+		    || (funcClass & VirtualThunkFunctionClass) == VirtualThunkFunctionClass)
+		{
+			needsThisPtr = true;
+		}
+		else if ((funcClass & StaticFunctionClass) != StaticFunctionClass
+		         && (funcClass & GlobalFunctionClass) != GlobalFunctionClass)
+		{
+			needsThisPtr = true;
+		}
+	}
+
+	if (needsThisPtr)
+	{
+		// Insert implicit "this" parameter for thiscall
+		// TODO: Replace this with calling convention / platform callbacks to insert thisptr (ask rss)
+		QualifiedName thisName = m_varName;
+		if (thisName.size() > 0)
+			thisName.erase(thisName.end() - 1);
+		params.push_back(FunctionParameter("this", Type::PointerType(m_arch, Type::NamedType(thisName, Type::VoidType())), true, {}));
+	}
+
+	DemangleVariableList(params, m_backrefList);
+
+	if (params.size() >= 1 && params.back().type->GetClass() == VoidTypeClass)
+		params.pop_back();
+
+	// TODO: fix calling convention
+	TypeBuilder newType = TypeBuilder::FunctionType(shouldHaveReturnType ? returnType.Finalize() : Type::VoidType(), nullptr, params);
+	newType.SetConst(_const);
+	newType.SetVolatile(_volatile);
+	newType.SetPointerSuffix(suffix);
+	newType.SetNameType(classFunctionType);
+	newType.SetCallingConventionName(cc);
+	auto convention = GetCallingConventionForType(cc);
+	if (convention)
+		newType.SetCallingConvention(convention);
+
+	m_logger->LogDebug("Successfully Created Function Type!\n");
+	return newType;
+}
+
+
+TypeBuilder Demangle::DemangleData()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	bool _const = false, _volatile = false, isMember = false;
+	QualifiedName name;
+	m_logger->Indent();
+	TypeBuilder newType = DemangleVarType(m_backrefList, false, name);
+	m_logger->Dedent();
+	auto suffix = DemanglePointerSuffix();
+	DemangleModifiers(_const, _volatile, isMember);
+	newType.SetConst(_const);
+	newType.SetVolatile(_volatile);
+	newType.SetPointerSuffix(suffix);
+	return newType;
+}
+
+
+TypeBuilder Demangle::DemanagleRTTI(BNNameType nameType)
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	bool _const = false, _volatile = false, isMember = false;
+	if (reader.Length() > 0)
+		DemangleModifiers(_const, _volatile, isMember);
+	QualifiedName typeName = m_varName;
+	m_logger->LogDebug("new struct type\n");
+	TypeBuilder newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+		StructNamedTypeClass, typeName));
+	newType.SetNameType(nameType);
+	newType.SetConst(_const);
+	newType.SetVolatile(_volatile);
+	m_logger->LogDebug("log: %s\n", newType.GetString().c_str());
+	return newType;
+}
+
+
+TypeBuilder Demangle::DemangleVTable()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	bool _const = false, _volatile = false, isMember = false;
+	DemangleModifiers(_const, _volatile, isMember);
+	TypeBuilder newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+		StructNamedTypeClass, m_varName));
+	if (reader.Peek() != '@')
+	{
+		QualifiedName typeName;
+		BNNameType classFunctionType = NoNameType;
+		DemangleName(typeName, classFunctionType, m_backrefList);
+		string suffix = m_varName.back();
+		m_varName.back() += "{for `" + typeName.GetString() + "'}";
+
+		typeName.push_back(suffix);
+		newType = TypeBuilder::NamedType(NamedTypeReference::GenerateAutoDemangledTypeReference(
+			StructNamedTypeClass, typeName));
+	}
+	newType.SetConst(_const);
+	newType.SetVolatile(_volatile);
+	newType.SetNameType(VFTableNameType);
+	return newType;
+}
+
+
+
+Demangle::DemangleContext Demangle::DemangleSymbol()
+{
+	m_logger->LogDebug("%s: '%s'\n", __FUNCTION__, reader.GetRaw());
+	m_logger->Indent();
+	BNNameType classFunctionType = NoNameType;
+	QualifiedName varName;
+
+	if (reader.Peek() == '.')
+	{
+		reader.Consume();
+
+		return { DemangleTypeInfoName(), NoAccess, NoScope };
+	}
+
+	if (reader.Read() != '?')
+	{
+		throw DemangleException();
+	}
+
+	DemangleName(varName, classFunctionType, m_backrefList);
+	m_logger->LogDebug("Done demangling Name: '%s' - '%s'", varName.GetString().c_str(), reader.GetRaw());
+	m_varName = varName;
+
+	DemangleContext context;
+
+	if (classFunctionType == StringNameType)
+	{
+		context = { DemangleString(), NoAccess, NoScope };
+		return context;
+	}
+
+	char funcType = reader.Read();
+	switch(funcType)
+	{
+	case '0': context = {DemangleData(),                      PrivateAccess,   StaticScope }; break;
+	case '1': context = {DemangleData(),                      ProtectedAccess, StaticScope }; break;
+	case '2': context = {DemangleData(),                      PublicAccess,    StaticScope }; break;
+	case '3': context = {DemangleData(),                      NoAccess,        NoScope     }; break;
+	case '4': context = {DemangleData(),                      NoAccess,        NoScope     }; break;
+	case '5': context = {DemangleVTable(),                    NoAccess,        NoScope     }; break;
+	case '6': context = {DemangleVTable(),                    NoAccess,        NoScope     }; break;
+	case '7': context = {DemangleVTable(),                    NoAccess,        NoScope     }; break;
+	case '8': context = {DemanagleRTTI(classFunctionType),    NoAccess,        NoScope     }; break;
+	case '9': context = {DemanagleRTTI(classFunctionType),    NoAccess,        NoScope     }; break;
+	case 'A': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass),                              PrivateAccess,   NoScope     }; break;
+	case 'B': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass),                              PrivateAccess,   NoScope     }; break;
+	case 'C': context = {DemangleFunction(classFunctionType, false, m_backrefList, PrivateFunctionClass | StaticFunctionClass),        PrivateAccess,   StaticScope }; break;
+	case 'D': context = {DemangleFunction(classFunctionType, false, m_backrefList, PrivateFunctionClass | StaticFunctionClass),        PrivateAccess,   StaticScope }; break;
+	case 'E': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass | VirtualFunctionClass),       PrivateAccess,   VirtualScope}; break;
+	case 'F': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass | VirtualFunctionClass),       PrivateAccess,   VirtualScope}; break;
+	case 'G': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass | StaticThunkFunctionClass),   PrivateAccess,   ThunkScope  }; break;
+	case 'H': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PrivateFunctionClass | StaticThunkFunctionClass),   PrivateAccess,   ThunkScope  }; break;
+	case 'I': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass),                            ProtectedAccess, NoScope     }; break;
+	case 'J': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass),                            ProtectedAccess, NoScope     }; break;
+	case 'K': context = {DemangleFunction(classFunctionType, false, m_backrefList, ProtectedFunctionClass | StaticFunctionClass),      ProtectedAccess, StaticScope }; break;
+	case 'L': context = {DemangleFunction(classFunctionType, false, m_backrefList, ProtectedFunctionClass | StaticFunctionClass),      ProtectedAccess, StaticScope }; break;
+	case 'M': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass | VirtualFunctionClass),     ProtectedAccess, VirtualScope}; break;
+	case 'N': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass | VirtualFunctionClass),     ProtectedAccess, VirtualScope}; break;
+	case 'O': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass | StaticThunkFunctionClass), ProtectedAccess, ThunkScope  }; break;
+	case 'P': context = {DemangleFunction(classFunctionType, true,  m_backrefList, ProtectedFunctionClass | StaticThunkFunctionClass), ProtectedAccess, ThunkScope  }; break;
+	case 'Q': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass),                               PublicAccess,    NoScope     }; break;
+	case 'R': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass),                               PublicAccess,    NoScope     }; break;
+	case 'S': context = {DemangleFunction(classFunctionType, false, m_backrefList, PublicFunctionClass | StaticFunctionClass),         PublicAccess,    StaticScope }; break;
+	case 'T': context = {DemangleFunction(classFunctionType, false, m_backrefList, PublicFunctionClass | StaticFunctionClass),         PublicAccess,    StaticScope }; break;
+	case 'U': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass | VirtualFunctionClass),        PublicAccess,    VirtualScope}; break;
+	case 'V': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass | VirtualFunctionClass),        PublicAccess,    VirtualScope}; break;
+	case 'W': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass | StaticThunkFunctionClass),    PublicAccess,    ThunkScope  }; break;
+	case 'X': context = {DemangleFunction(classFunctionType, true,  m_backrefList, PublicFunctionClass | StaticThunkFunctionClass),    PublicAccess,    ThunkScope  }; break;
+	case 'Y': context = {DemangleFunction(classFunctionType, false, m_backrefList, GlobalFunctionClass),                               NoAccess,        NoScope     }; break;
+	case 'Z': context = {DemangleFunction(classFunctionType, false, m_backrefList, GlobalFunctionClass),                               NoAccess,        NoScope     }; break;
+	case '$':
+	{
+		int funcClass = VirtualThunkFunctionClass;
+		if (reader.Peek() == 'R')
+		{
+			reader.Consume();
+			funcClass |= VirtualThunkExFunctionClass;
+		}
+		char thunkType = reader.Read();
+		switch (thunkType)
+		{
+		case '0': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | PrivateFunctionClass),   PrivateAccess,   ThunkScope}; break;
+		case '1': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | PrivateFunctionClass),   PrivateAccess,   ThunkScope}; break;
+		case '2': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | ProtectedFunctionClass), ProtectedAccess, ThunkScope}; break;
+		case '3': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | ProtectedFunctionClass), ProtectedAccess, ThunkScope}; break;
+		case '4': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | PublicFunctionClass),    PublicAccess,    ThunkScope}; break;
+		case '5': context = {DemangleFunction(classFunctionType, true, m_backrefList, funcClass | VirtualFunctionClass | PublicFunctionClass),    PublicAccess,    ThunkScope}; break;
+		default: throw DemangleException("Unknown virtual thunk type " + string(1, thunkType));
+		}
+		break;
+	}
+	default:  throw DemangleException("Unknown function type " + string(1, funcType));
+	}
+	return context;
+}
+
+bool Demangle::DemangleMS(Architecture* arch, const string& mangledName, Ref<Type>& outType,
+                          QualifiedName& outVarName, const Ref<BinaryView>& view)
+{
+	outType = nullptr;
+	if (mangledName.empty() || (mangledName[0] != '?' && mangledName[0] != '.'))
+		return false;
+	return DemangleMS(arch, mangledName, outType, outVarName);
+}
+
+bool Demangle::DemangleMS(Architecture* arch, const string& mangledName, Ref<Type>& outType,
+                          QualifiedName& outVarName, BinaryView* view)
+{
+	outType = nullptr;
+	if (mangledName.empty() || (mangledName[0] != '?' && mangledName[0] != '.'))
+		return false;
+	return DemangleMS(arch, mangledName, outType, outVarName);
+}
+
+bool Demangle::DemangleMS(Architecture* arch, const string& mangledName, Ref<Type>& outType,
+                          QualifiedName& outVarName)
+{
+	outType = nullptr;
+	if (mangledName.empty() || (mangledName[0] != '?' && mangledName[0] != '.'))
+		return false;
+	try
+	{
+		Demangle demangle(arch, mangledName);
+		// For now we're throwing away MemberScope and MemberAccess
+		outType = demangle.DemangleSymbol().type.Finalize();
+		outVarName = demangle.GetVarName();
+
+	}
+	catch (DemangleException &e)
+	{
+		LogDebug("Demangling Failed '%s' '%s;", mangledName.c_str(), e.what());
+		return false;
+	}
+	return true;
+}
+
+
+bool Demangle::DemangleMS(const string& mangledName, Ref<Type>& outType,
+                          QualifiedName& outVarName, const Ref<BinaryView>& view)
+{
+	outType = nullptr;
+	if (mangledName.empty() || (mangledName[0] != '?' && mangledName[0] != '.'))
+		return false;
+	try
+	{
+		Demangle demangle(view, mangledName);
+		// For now we're throwing away MemberScope and MemberAccess
+		outType = demangle.DemangleSymbol().type.Finalize();
+		outVarName = demangle.GetVarName();
+
+	}
+	catch (DemangleException &e)
+	{
+		LogDebug("Demangling Failed '%s' '%s;", mangledName.c_str(), e.what());
+		return false;
+	}
+	return true;
+}
+
+
+class MSDemangler: public Demangler
+{
+public:
+	MSDemangler(): Demangler("MS")
+	{
+	}
+	~MSDemangler() override {}
+
+	virtual bool IsMangledString(const string& name) override
+	{
+		return name[0] == '?';
+	}
+
+	virtual bool Demangle(Ref<Architecture> arch, const string& name, Ref<Type>& outType, QualifiedName& outVarName,
+	                      Ref<BinaryView> view) override
+	{
+		if (view)
+			return Demangle::DemangleMS(arch, name, outType, outVarName, view);
+		return Demangle::DemangleMS(arch, name, outType, outVarName);
+	}
+};
+
+
+extern "C"
+{
+	BN_DECLARE_CORE_ABI_VERSION
+
+#ifdef DEMO_EDITION
+	bool DemangleMSVCPluginInit()
+#else
+	BINARYNINJAPLUGIN bool CorePluginInit()
+#endif
+	{
+		static MSDemangler* demangler = new MSDemangler();
+		Demangler::Register(demangler);
+		return true;
+	}
+}
diff --git a/demangler/msvc/demangle_msvc.h b/demangler/msvc/demangle_msvc.h
new file mode 100644
index 00000000..d52b666a
--- /dev/null
+++ b/demangler/msvc/demangle_msvc.h
@@ -0,0 +1,162 @@
+// Copyright 2016-2024 Vector 35 Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <stdexcept>
+#include <exception>
+#include <string>
+#include <vector>
+#include <set>
+#include "binaryninjaapi.h"
+
+
+class DemangleException: public std::exception
+{
+	std::string m_message;
+public:
+	DemangleException(std::string msg="Attempt to read beyond bounds or missing expected character"): m_message(msg){}
+	virtual const char* what() const noexcept { return m_message.c_str(); }
+};
+
+
+class Demangle
+{
+	enum NameType
+	{
+		NameEmpty,
+		NameString,
+		NameLookup,
+		NameBackref,
+		NameTemplate,
+		NameConstructor,
+		NameDestructor,
+		NameRtti,
+		NameReturn,
+		NameDynamicInitializer,
+		NameDynamicAtExitDestructor,
+		NameLocalStaticThreadGuard,
+		NameLocalVftable
+	};
+
+	enum FunctionClass
+	{
+		NoneFunctionClass           = 0,
+		PrivateFunctionClass        = 1 << 0,
+		ProtectedFunctionClass      = 1 << 1,
+		PublicFunctionClass         = 1 << 2,
+		GlobalFunctionClass         = 1 << 3,
+		StaticFunctionClass         = 1 << 4,
+		VirtualFunctionClass        = 1 << 5,
+		FriendFunctionClass         = 1 << 6,
+		StaticThunkFunctionClass    = 1 << 7,
+		VirtualThunkFunctionClass   = 1 << 8,
+		VirtualThunkExFunctionClass = 1 << 9,
+	};
+
+	class Reader
+	{
+	public:
+		Reader(std::string data);
+		std::string PeekString(size_t count=1);
+		char Peek();
+		const char* GetRaw();
+		char Read();
+		std::string ReadString(size_t count=1);
+		std::string ReadUntil(char sentinal);
+		void Consume(size_t count=1);
+		size_t Length();
+	private:
+		std::string m_data;
+	};
+
+	class BackrefList
+	{
+	public:
+		std::vector<BinaryNinja::TypeBuilder> typeList;
+		std::vector<std::string> nameList;
+		const BinaryNinja::TypeBuilder& GetTypeBackref(size_t reference);
+		std::string GetStringBackref(size_t reference);
+		void PushTypeBackref(BinaryNinja::TypeBuilder t);
+		void PushStringBackref(std::string& s);
+		void PushFrontStringBackref(std::string& s);
+	};
+
+	Reader reader;
+	BackrefList m_backrefList;
+	BinaryNinja::Architecture* m_arch;
+	BinaryNinja::Ref<BinaryNinja::Platform> m_platform;
+	BinaryNinja::Ref<BinaryNinja::BinaryView> m_view;
+	BinaryNinja::QualifiedName m_varName;
+	BinaryNinja::Ref<BinaryNinja::Logger> m_logger;
+
+	NameType GetNameType();
+	BinaryNinja::TypeBuilder DemangleVarType(BackrefList& varList, bool isReturn, BinaryNinja::QualifiedName& name);
+	void DemangleNumber(int64_t& num);
+	void DemangleChar(char& ch);
+	void DemangleWideChar(uint16_t& wch);
+	void DemangleModifiers(bool& _const, bool& _volatile, bool& isMember);
+	std::set<BNPointerSuffix> DemanglePointerSuffix();
+	void DemangleVariableList(std::vector<BinaryNinja::FunctionParameter>& paramList, BackrefList& varList);
+	void DemangleNameTypeRtti(BNNameType& classFunctionType,
+	                          BackrefList& nameBackrefList,
+	                          std::string& out,
+	                          std::string& rttiTypeName);
+	void DemangleTypeNameLookup(std::string& out, BNNameType& functionType);
+	void DemangleNameTypeString(std::string& out);
+	void DemangleNameTypeBackref(std::string& out, const std::vector<std::string>& backrefList);
+	void DemangleName(BinaryNinja::QualifiedName& nameList,
+	                  BNNameType& classFunctionType,
+	                  BackrefList& nameBackrefList);
+	BinaryNinja::Ref<BinaryNinja::CallingConvention> GetCallingConventionForType(BNCallingConventionName ccName);
+	BNCallingConventionName DemangleCallingConvention();
+	BinaryNinja::TypeBuilder DemangleFunction(BNNameType classFunctionType, bool pointerSuffix, BackrefList& varList, int funcClass = NoneFunctionClass);
+	BinaryNinja::TypeBuilder DemangleData();
+	void DemangleNameTypeRtti(BNNameType& classFunctionType,
+	                          BackrefList& nameBackrefList,
+	                          std::string& out);
+	BinaryNinja::TypeBuilder DemangleVTable();
+	BinaryNinja::TypeBuilder DemanagleRTTI(BNNameType classFunctionType);
+	std::string DemangleTemplateInstantiationName(BackrefList& nameBackrefList);
+	std::string DemangleTemplateParams(std::vector<BinaryNinja::FunctionParameter>& params, BackrefList& nameBackrefList, std::string& out);
+	std::string DemangleUnqualifiedSymbolName(BinaryNinja::QualifiedName& nameList, BackrefList& nameBackrefList, BNNameType& classFunctionType);
+	BinaryNinja::TypeBuilder DemangleString();
+	BinaryNinja::TypeBuilder DemangleTypeInfoName();
+
+public:
+	struct DemangleContext
+	{
+		BinaryNinja::TypeBuilder type;
+		BNMemberAccess access;
+		BNMemberScope scope;
+	};
+	Demangle(BinaryNinja::Architecture* arch, std::string mangledName);
+	Demangle(BinaryNinja::Ref<BinaryNinja::BinaryView> view, std::string mangledName);
+	Demangle(BinaryNinja::Ref<BinaryNinja::Platform> platform, std::string mangledName);
+	DemangleContext DemangleSymbol();
+	BinaryNinja::QualifiedName GetVarName() const { return m_varName; }
+
+	// Be careful not to accidentally implicitly cast a BinaryView* to a bool
+	static bool DemangleMS(BinaryNinja::Architecture* arch, const std::string& mangledName, BinaryNinja::Ref<BinaryNinja::Type>& outType,
+	                       BinaryNinja::QualifiedName& outVarName, const BinaryNinja::Ref<BinaryNinja::BinaryView>& view);
+	static bool DemangleMS(BinaryNinja::Architecture* arch, const std::string& mangledName, BinaryNinja::Ref<BinaryNinja::Type>& outType,
+	                       BinaryNinja::QualifiedName& outVarName, BinaryNinja::BinaryView* view);
+	static bool DemangleMS(BinaryNinja::Architecture* arch, const std::string& mangledName, BinaryNinja::Ref<BinaryNinja::Type>& outType,
+	                       BinaryNinja::QualifiedName& outVarName);
+
+	static bool DemangleMS(const std::string& mangledName, BinaryNinja::Ref<BinaryNinja::Type>& outType,
+	                       BinaryNinja::QualifiedName& outVarName, const BinaryNinja::Ref<BinaryNinja::BinaryView>& view);
+	static bool DemangleMS(const std::string& mangledName, BinaryNinja::Ref<BinaryNinja::Type>& outType,
+	                       BinaryNinja::QualifiedName& outVarName, BinaryNinja::BinaryView* view);
+};
+