public static String getDirectoryName(String path) {
			if (path != null) {
				int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR);
				int index2 = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR);
				if (index2 > index) {
					index = index2;
				}
				if (index != -1) {
					if (index == path.length() - 1) {
						if (path.indexOf(VOLUME_SEPARATOR_CHAR) == index - 1) {
							return null;
						} else {
							path = path.substring(0, index);
						}
					} else {
						if (path.indexOf(VOLUME_SEPARATOR_CHAR) == index - 1) {
							path = path.substring(0, index + 1);
						} else {
							path = path.substring(0, index);
						}
					}
					if (path.length() == 2 && path[1] == VOLUME_SEPARATOR_CHAR) {
						return "";
					}
				}
				return path;
			}
			return null;
		}

 LocalInfo(TypeInfo type, String name, int index, Label beginLabel, Label endLabel) {
     this.type = type;
     this.name = name;
     this.index = index;
     this.beginLabel = beginLabel;
     this.endLabel = endLabel;
 }

        public static void main(String[] args) {
            System.out.println();
            System.out.println();
			var result = new Application().run(args);
			System.out.println("Done("+result+")");
            System.exit(result);
        }

 void buildPackageDocumentation(String packageName, PackageDeclarationNode packageDeclaration) {
     var comment = ParserHelper.decodeDocumentation(context.Text, packageDeclaration.DocumentationOffset,
             packageDeclaration.DocumentationLength);
     memberKind = null;
     node = packageDeclaration;
     appendDocumentation("N:" + packageName, comment);
 }

 public NumberFormat addLeadingDigitsPattern(String value)
 {
     if (value == null) {
     throw new NullPointerException();
       }
       leadingDigitsPattern_.add(value);
       return this;
 }

 /*
 public void writeFloat(float v) {
 writeInt(Float.floatToIntBits(v));
 }
 public void writeDouble(double v) {
 writeLong(Double.doubleToLongBits(v));
 }
 */
 public void writeBytes(String s)
 {
     int len = s.length();
     for (int i = 0 ; i < len ; i++) {
     @out.write((byte)s.charAt(i));
     }
     incCount(len);
 }

		public CodeError(String filename, int id, int level, String message, int line, int column) {
			this.Filename = filename;
			this.Id = id;
			this.Level = level;
			this.Message = message;
			this.Line = line;
			this.Column = column;
		}

		public String getMessage(Locale locale, String key, params Object[] args) {
			var rb = getResourceBundle(locale);
			if (rb != null) {
				try {
					return MessageFormat.format(rb.getString(key), args);
				} catch {
				}
			}
			return key;
		}

		public static bool hasNature(IProject project, String natureId) {
			if (project.exists() && project.isOpen()) {
				try {
					return project.hasNature(natureId);
				} catch (CoreException e) {
					Environment.logException(e);
				}
			}
			return false;
		}

     	: super(typeSystem, name) {
     this.typeSystem = typeSystem;
     this.descriptor = "L" + name + ";";
     numericTypeKind = TypeKinds[name];
     if (numericTypeKind == null) {
         numericTypeKind = NumericTypeKind.None;
     }
     new ClassReader(bytes).accept(new OutlineVisitor(this), ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
     
     this.genericsScope = new Scope<String, TypeInfo>();
     this.genericsScope.enterScope();
 }

 /**
    * Creates a new match.
    *
    * @param start  the start index into the target text
    * @param rawString  the matched substring of the target text
    * @param number  the matched phone number
    */
 internal PhoneNumberMatch(int start, String rawString, PhoneNumber number)
 {
     if (start < 0) {
       throw new IllegalArgumentException("Start index must be >= 0.");
     }
     if (rawString == null || number == null) {
       throw new NullPointerException();
     }
     this._start = start;
     this._rawString = rawString;
     this._number = number;
 }

 public static MemberInfo getInfo(MethodInfo getAccessor, MethodInfo setAccessor, String name) {
     var result = (getAccessor ?? setAccessor).getUserData(typeof(PropertyMemberInfo));
     if (result == null) {
         result = new PropertyMemberInfo(getAccessor, setAccessor, name);
         if (getAccessor != null) {
             getAccessor.addUserData(result);
         }
         if (setAccessor != null) {
             setAccessor.addUserData(result);
         }
     }
     return result;
 }

		public static String getFileName(String path) {
			if (path != null) {
				int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR);
				if (index == -1) {
					index = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR);
				}
				if (index == -1) {
					return path;
				}
				return path.substring(index + 1);
			}
			return null;
		}

		public void addTypeToTypeRelation(String referencingType, String referencedType) {
			var referencing = referencingTypes.get(referencedType);
			if (referencing == null) {
				referencing = new HashSet<String>();
				referencingTypes[referencedType] = referencing;
			}
			referencing.add(referencingType);
			var referenced = referencedTypes.get(referencingType);
			if (referenced == null) {
				referenced = new HashSet<String>();
				referencedTypes[referencingType] = referenced;
			}
			referenced.add(referencedType);
		}

		public void addFileToTypeRelation(String fileName, String typeName) {
			var contents = fileContents.get(fileName);
			if (contents == null) {
				contents = new HashSet<String>();
				fileContents[fileName] = contents;
			}
			contents.add(typeName);
			var locations = typeLocations.get(typeName);
			if (locations == null) {
				locations = new HashSet<String>();
				typeLocations[typeName] = locations;
			}
			locations.add(fileName);
		}

 public static String quoteReplacement(String s)
 {
     if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
     return s;
     StringBuilder sb = new StringBuilder();
     for (int i=0; i<s.length(); i++) {
     char c = s.charAt(i);
     if (c == '\\' || c == '$') {
         sb.append('\\');
     }
     sb.append(c);
     }
     return sb.toString();
 }

		public void testArrays() {
			var c = new Container();
			
			var obj = new Object();
			var str = "abc";
			var arr = new String[] { "a", "b", "c" };
			c.addUserData(obj);
			c.addUserData(str);
			c.addUserData(arr);
			
			Assert.assertEquals(obj, c.getUserData(typeof(Object)));
			Assert.assertEquals("abc", c.getUserData(typeof(String)));
			Assert.assertEquals((Object)arr, c.getUserData(typeof(String[])));
		}

 public static long decodeHexadecimalLong(String value) {
     long result = 0;
     var ndigits = 0;
     for (var i = 2; i < value.length(); i++) {
         var digit = ParserHelper.scanHexDigit(value[i]);
         if (ndigits == 0 && digit == 0) {
             continue;
         }
         result <<= 4;
         result |= digit;
         if (++ndigits == 17) {
             throw new NumberFormatException(value);
         }
     }
     return result;
 }

		public static String getFileNameWithoutExtension(String path) {
			if (path != null) {
				int index = path.lastIndexOf(DIRECTORY_SEPARATOR_CHAR);
				if (index == -1) {
					index = path.lastIndexOf(ALT_DIRECTORY_SEPARATOR_CHAR);
				}
				if (index != -1) {
					path = path.substring(index + 1);
				}
				index = path.lastIndexOf('.');
				if (index == -1) {
					return path;
				}
				return path.substring(0, index);
			}
			return null;
		}

        public Library(String[] classPath, Library parent) {
			this.classPath = new ArrayList<String>();
			foreach(string path in classPath)
				this.classPath.add(path);
            this.fileClasses = new HashMap<String, File>(128);
            int capacity = (parent == null) ? 0x5000 : 128;
            this.jarClasses = new HashMap<String, ZipFile>(capacity);
            this.classNames = new ArrayList<String>(capacity);
            this.typeInfos = new HashMap<String, TypeInfo>();
			this.constructedGenericTypes = new HashMap<TypeInfo, ArrayList<TypeInfo>>();
			this.constructedGenericMethods = new HashMap<MethodInfo, ArrayList<MethodInfo>>();
            this.parent = parent;

			if (parent == null) {
	            initializeBootClasses();
			}
            
            foreach (var path in classPath) {
                explorePath(path);
            }
        }