Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toModulePath(ModuleIdentifier module) {
        String pattern = getBase().getPath();
        if (!pattern.endsWith(MavenPattern.M2_PATTERN)) {

        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override
    public ExternalResourceName toVersionListPattern(ModuleIdentifier module, IvyArtifactName artifact) {
        Map<String, String> attributes = toAttributes(module, artifact);
        return getBase().getRoot().resolve(substituteTokens(getBase().getPath(), attributes));
    }

    @Override

        this.name = name;
        this.base = base;
        this.lenient = lenient;
    }

    public String getName() {
        return name;
    }

    public String getBase() {
        return base;
    }

    public boolean isLenient() {
        return lenient;
    }

        // Replace encoded [] with plain variants, since we are using them with a special meaning here.
        return pattern.getDisplayable().replace("%5B", "[").replace("%5D", "]");
    }

    protected ExternalResourceName getBase() {
        return pattern;
    }

    protected String substituteTokens(String pattern, Map<String, String> attributes) {
        return PatternHelper.substituteTokens(pattern, attributes);
    }

		return start - *stextOffset, true
	}
	return 0, false
}

// GetBase determines the base address to subtract from virtual
// address to get symbol table address. For an executable, the base
// is 0. Otherwise, it's a shared library, and the base is the
// address where the mapping starts. The kernel needs special handling.

        Map<String, ComponentVariant> variantsByName = declaredVariants.stream().collect(Collectors.toMap(ComponentVariant::getName, Function.identity()));
        for (AdditionalVariant additionalVariant : additionalVariants) {
            String baseName = additionalVariant.getBase();
            ImmutableAttributes attributes;
            ImmutableCapabilities capabilities;

            builder.addAll(variants.get());
        } else {
            variantsByName = Collections.emptyMap();
        }
        for (AdditionalVariant additionalVariant : variantMetadataRules.getAdditionalVariants()) {
            String baseName = additionalVariant.getBase();
            VariantGraphResolveMetadata base = null;

	hexadecimalDigits = "0123456789aAbBcCdDeEfF"
	sign              = "+-"
	period            = "."
	exponent          = "eEpP"
)

// getBase returns the numeric base represented by the verb and its digit string.
func (s *ss) getBase(verb rune) (base int, digits string) {
	s.okVerb(verb, "bdoUxXv", "integer") // sets s.err
	base = 10
	digits = decimalDigits
	switch verb {
	case 'b':
		base = 2

          op.getOperation()->getOperand(to));
    }
    BitVector operands_to_erase(op->getNumOperands());
    int args_start = op->getNumOperands()
                         ? op.getArgOperands().getBase()->getOperandNumber()
                         : 0;
    operands_to_erase |= args_to_erase.lookup(func);
    operands_to_erase <<= args_start;
    op->eraseOperands(operands_to_erase);

        for (AdditionalVariant additionalVariant : additionalVariants) {
            String name = additionalVariant.getName();
            String baseName = additionalVariant.getBase();
            ImmutableAttributes attributes;
            ImmutableCapabilities capabilities;