public static RustPath parse(Symbol s) {
		int pos = s.pos - 1;

		if (s.nextChar() == 'B') {
			String backref = s.parseBackref();
			int i = Integer.parseInt(backref, 16);
			RustBackref b = new RustBackref(i, s);
			RustPath path = new RustPath(b);
			return path;
		}

		char c = s.popChar();
		if (c == 'C') {
			// Crate root?
			RustIdentifier identifier = RustIdentifier.parse(s, new RustNamespace("crate"));
			s.backrefAdd(pos, identifier);
			return new RustPath(identifier.toString());
		}
		else if (c == 'M') {
			RustImplPath implPath = RustImplPath.parse(s);
			RustType type = RustType.parse(s);
			RustPath path = new RustPath("<" + implPath + "::" + type + ">");

			s.backrefAdd(pos, path);
			return path;
			// <impl-path> <type>
			// <T> (inherent impl)
		}
		else if (c == 'X') {
			RustImplPath.parse(s);
			RustType type = RustType.parse(s);
			RustPath parent = RustPath.parse(s);
			RustPath path = new RustPath("<" + type + " as " + parent + ">");
			s.backrefAdd(pos, path);
			return path;
			// <impl-path> <type> <data>
			// <T as Trait> (trait impl)
		}
		else if (c == 'Y') {
			RustType type = RustType.parse(s);
			RustPath parent = RustPath.parse(s);

			RustPath path = new RustPath("<" + type + " as " + parent + ">");
			s.backrefAdd(pos, path);
			return path;
			// <type> <data>
			// <T as Trait> (trait definition)
		}
		else if (c == 'N') {
			RustNamespace namespace = RustNamespace.parse(s);
			RustPath parent = RustPath.parse(s);
			RustIdentifier id = RustIdentifier.parse(s, namespace);
			RustPathNested nested = new RustPathNested(parent, id);

			RustPath path = new RustPath(nested.toString());
			s.backrefAdd(pos, path);
			return path;
		}
		else if (c == 'I') {
			RustPath parent = RustPath.parse(s);
			RustGenericArgs args = RustGenericArgs.parse(s);

			if (args == null) {
				RustPath path = new RustPath(parent);
				s.backrefAdd(pos, path);
				return path;
			}

			RustPath path = new RustPath("" + parent + args);
			s.backrefAdd(pos, path);
			return path;
		}
		else if (c == 'B') {
			s.backChar();
			String b = s.parseBackref();
			int i = Integer.parseInt(b, 16);
			RustBackref br = new RustBackref(i, s);
			return new RustPath(br);
		}

		return null;
	}
Parses a rust path from a mangled symbol
@param s parse the rust path
@return the rust path object
Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/rust/demangler/RustDemanglerV0.java