private TypeRef([NotNull] string typeName, [CanBeNull] AssemblyRef assembly)
    {
      Assert.ArgumentNotNull(typeName, "typeName");

      TypeName = typeName;
      Assembly = assembly ?? AssemblyRef.Empty;
    }

		public Csvm(IDeobfuscatorContext deobfuscatorContext, ModuleDefMD module, Csvm oldOne) {
			this.deobfuscatorContext = deobfuscatorContext;
			this.module = module;
			if (oldOne.resource != null)
				this.resource = (EmbeddedResource)module.Resources[oldOne.module.Resources.IndexOf(oldOne.resource)];
			if (oldOne.vmAssemblyRef != null)
				this.vmAssemblyRef = module.ResolveAssemblyRef(oldOne.vmAssemblyRef.Rid);
		}

		public AssemblyReferenceNodeImpl(ITreeNodeGroup treeNodeGroup, ModuleDef asmRefOwnerModule, AssemblyRef assemblyRef) {
			TreeNodeGroup = treeNodeGroup;
			this.asmRefOwnerModule = new WeakReference(asmRefOwnerModule);
			// Make sure we don't hold on to the original reference since it could prevent GC of the
			// owner module.
			AssemblyRef = assemblyRef.ToAssemblyRef();
			AssemblyRef.Rid = assemblyRef.Rid;
		}

 public TypeDefOrRefSig FindOrCreateTypeRef(ModuleDef module, AssemblyRef asmRef, string ns, string name, bool isValueType)
 {
     var typeRef = module.UpdateRowId(new TypeRefUser(module, ns, name, asmRef));
     if (isValueType)
         return new ValueTypeSig(typeRef);
     
     return new ClassSig(typeRef);
 }

		static MModule GetModule(AssemblyRef asmRef) {
			foreach (var mm in modules.Values) {
				var asm = mm.moduleDef.Assembly;
				if (asm != null && asm.FullName == asmRef.FullName)
					return mm;
			}
			return null;
		}

		static void OverwriteAssembly(AssemblyRef dst, AssemblyRef src) {
			dst.Name = src.Name;
			dst.Version = src.Version;
			dst.PublicKeyOrToken = src.PublicKeyOrToken;
			dst.Culture = src.Culture;
			dst.Attributes = src.Attributes;
			dst.Hash = src.Hash;
		}

 public AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly)
 {
     if (parentAssembly == null)
         throw new ArgumentNullException("parentAssembly");
     if (r == null)
         throw new ArgumentNullException("r");
     this.r = r;
     this.parentAssembly = parentAssembly;
     this.LazyLoading = true;
 }

		internal AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly, DnSpyFileListTreeNode dnSpyFileListTreeNode) {
			if (parentAssembly == null)
				throw new ArgumentNullException("parentAssembly");
			if (dnSpyFileListTreeNode == null)
				throw new ArgumentNullException("dnSpyFileListTreeNode");
			if (r == null)
				throw new ArgumentNullException("r");
			this.r = r;
			this.dnSpyFileListTreeNode = dnSpyFileListTreeNode;
			this.parentAssembly = parentAssembly;
			this.LazyLoading = true;
		}

		private ISymbolWriter LoadSymbolWriter(AssemblyDefinition assembly, AssemblyRef output)
		{
			// TODO: Get symbol writing to work.
//			ISymbolWriterProvider symProv = null;
//			if (this.usingMdb) {
//				symProv = new Mono.Cecil.Mdb.MdbWriterProvider ();
//			} else if (this.usingPdb) {
//				symProv = new Mono.Cecil.Pdb.PdbWriterProvider ();
//			} else {
//				this.warnings.Add ("-writePDBFile specified, but no symbol file found, cannot write symbols.");
//			}
//			if (symProv != null) {
//				return output.IsFilename ?
//					symProv.GetSymbolWriter (assembly.MainModule, output.Filename) :
//					symProv.GetSymbolWriter (assembly.MainModule, output.Streams.Symbols);
//			}
			return null;
		}

 static bool IsAssemblyRef(AssemblyRef asmRef, UTF8String name, PublicKeyToken token)
 {
     if (asmRef.Name != name)
         return false;
     var pkot = asmRef.PublicKeyOrToken;
     if (pkot == null)
         return false;
     return token.Equals(pkot.Token);
 }

 /// <summary>
 /// Add an external assembly to this PEFile (.assembly extern)
 /// </summary>
 /// <param name="assemName">the external assembly name</param>
 /// <returns>a descriptor for this external assembly</returns>
 public AssemblyRef AddExternAssembly(string assemName) {
   if (assemName.CompareTo(mscorlibName) == 0) return metaData.mscorlib;
   AssemblyRef anAssem = new AssemblyRef(metaData,assemName);
   metaData.AddToTable(MDTable.AssemblyRef,anAssem);
   // Console.WriteLine("Adding assembly " + assemName);
   return anAssem;
 }

 /// <summary>
 /// Add a managed resource from another assembly.
 /// </summary>
 /// <param name="resName">The name of the resource</param>
 /// <param name="assem">The assembly where the resource is</param>
 /// <param name="isPublic">Access for the resource</param>
 public void AddExternalManagedResource (string resName, AssemblyRef assem, uint flags) {
   resources.Add (new ManifestResource (resName, flags, assem));
 }

		public ClassSig Type(string ns, string name, AssemblyRef asmRef) {
			return (ClassSig)Type(false, ns, name, asmRef);
		}

 public void Write(ISyntaxHighlightOutput output, ILanguage language, AssemblyRef asmRef, bool showToken)
 {
     output.Write(NameUtils.CleanIdentifier(asmRef.Name), TextTokenKind.Text);
     WriteToken(output, asmRef, showToken);
 }

		public void Find() {
			resource = FindCsvmResource();
			vmAssemblyRef = FindVmAssemblyRef();
		}

		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="name">Name of resource</param>
		/// <param name="asmRef">Assembly reference</param>
		/// <param name="flags">Resource flags</param>
		public AssemblyLinkedResource(UTF8String name, AssemblyRef asmRef, ManifestResourceAttributes flags)
			: base(name, flags) {
			if (asmRef == null)
				throw new ArgumentNullException("asmRef");
			this.asmRef = asmRef;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="TypeRef"/> class.
 /// </summary>
 /// <param name="assembly">The belonging assembly of this type reference, or <c>null</c> if it is mscorlib.</param>
 /// <param name="name">The value of <see cref="Type.FullName"/>, or <c>null</c> if referring type is <see cref="Object"/>.</param>
 public TypeRef(AssemblyRef assembly, String name)
     : this()
 {
     this.Assembly = assembly;
     this.Name = name;
 }

		public ManifestResource(string name, uint flags, AssemblyRef assemRef) 
		{
			InitResource (name, flags);
			rRef = assemRef;
		}

 internal static AssemblyRef ReadAssemblyRef(PEReader buff)
 {
     buff.SetElementPosition(MDTable.Assembly, 1);
     HashAlgorithmType hAlg = (HashAlgorithmType)buff.ReadUInt32();
     ushort majVer = buff.ReadUInt16();
     ushort minVer = buff.ReadUInt16();
     ushort bldNo = buff.ReadUInt16();
     ushort revNo = buff.ReadUInt16();
     uint flags = buff.ReadUInt32();
     byte[] pKey = buff.GetBlob();
     string name = buff.GetString();
     string cult = buff.GetString();
     AssemblyRef assemRef;
     if (name.ToLower() == "mscorlib")
     {
         assemRef = MSCorLib.mscorlib;
         assemRef.AddVersionInfo(majVer, minVer, bldNo, revNo);
         if (pKey.Length > 8) assemRef.AddKey(pKey);
         else assemRef.AddKeyToken(pKey);
         assemRef.AddCulture(cult);
         assemRef.SetFlags(flags);
     }
     else
     {
         assemRef = new AssemblyRef(name, majVer, minVer, bldNo, revNo, flags, pKey, cult, null);
     }
     //AssemblyRef assemRef = new AssemblyRef(name,majVer,minVer,bldNo,revNo,flags,pKey,cult,null);
     assemRef.ReadAsDef();
     return assemRef;
 }

 /// <summary>
 /// Make an AssemblyRef descriptor for this Assembly
 /// </summary>
 /// <returns>AssemblyRef descriptor for this Assembly</returns>
 public AssemblyRef MakeRefOf()
 {
     if (refOf == null)
     {
         refOf = new AssemblyRef(name, majorVer, minorVer, buildNo, revisionNo,
             flags, publicKey, culture, null);
     }
     return refOf;
 }