mask &= r.OutMask()
	if mask == 0 {
		return nil
	}

	// normalize the mask so that the set bits are left aligned
	o := bits.LeadingZeros64(^mask)
	mask = bits.RotateLeft64(mask, o)
	z := bits.LeadingZeros64(mask)
	mask = bits.RotateLeft64(mask, z)

	// check that the normalized mask is contiguous
	l := bits.LeadingZeros64(^mask)
	if l+bits.TrailingZeros64(mask) != 64 {
		return nil
	}

			// them.
			return Merge([]*Profile{p})
		}
	}

	return p, nil
}

// Normalize normalizes the source profile by multiplying each value in profile by the
// ratio of the sum of the base profile's values of that sample type to the sum of the
// source profile's value of that sample type.
func (p *Profile) Normalize(pb *Profile) error {

	if err := p.compatible(pb); err != nil {
		return err
	}

	funcs := map[reflect.Type]FillFunc{}
	funcs[reflect.TypeOf(&runtime.RawExtension{})] = func(s string, i int, obj interface{}) {
		// generate a raw object in normalized form
		// TODO: test non-normalized round-tripping... YAMLToJSON normalizes and makes exact comparisons fail
		obj.(*runtime.RawExtension).Raw = []byte(`{"apiVersion":"example.com/v1","kind":"CustomType","spec":{"replicas":1},"status":{"available":1}}`)
	}

        }

        String normalized = heapSize.trim().toLowerCase();
        try {
            if (normalized.endsWith("m")) {
                return Integer.parseInt(normalized.substring(0, normalized.length() - 1));
            }
            if (normalized.endsWith("g")) {
                return Integer.parseInt(normalized.substring(0, normalized.length() - 1)) * 1024;
            }

	if isGroup {
		dnValidator = sys.LDAPConfig.GetValidatedGroupDN
	}

	// map of normalized DN keys to original keys.
	normalizedDNKeysMap := make(map[string][]string)
	var collectedErrors []error
	for k := range policyMap {
		_, err := ldap.NormalizeDN(k)
		if err != nil {
			// not a valid DN, ignore.
			continue
		}

import org.codelibs.fess.suggest.index.contents.querylog.QueryLog;
import org.codelibs.fess.suggest.normalizer.Normalizer;

public interface ContentsParser {
    SuggestItem parseSearchWords(String[] words, String[][] readings, String[] fields, String[] tags, String roles[], long score,
            ReadingConverter readingConverter, Normalizer normalizer, SuggestAnalyzer analyzer, String[] langs);

        assertEquals("UTF-8", encodingHelper.normalize(enc));

        enc = "Shift_JIS";
        assertEquals("Shift_JIS", encodingHelper.normalize(enc));

        enc = "S-JIS";
        assertEquals("Shift_JIS", encodingHelper.normalize(enc));
    }

    public void test_normalize_null() {
        String enc;

        enc = null;
        assertNull(encodingHelper.normalize(enc));

        enc = "";

            return -1;
        }
        String normalized = notation.toLowerCase(Locale.US).trim();
        if (normalized.isEmpty()) {
            return -1;
        }
        try {
            if (normalized.endsWith("k")) {
                return parseWithFactor(normalized, KILO_FACTOR);
            }
            if (normalized.endsWith("m")) {
                return parseWithFactor(normalized, MEGA_FACTOR);
            }

                return null;
            }
        };

        final Normalizer normalizer = (text, field, lang) -> null;

        final Suggester suggester = Suggester.builder().settings(SuggestSettings.builder().setSettingsIndexName(settingsIndexName))
                .readingConverter(converter).normalizer(normalizer).build(runner.client(), id);

        assertEquals(runner.client(), suggester.client);

     * Note: Alias will be automatically normalized: '-', '_' and '.' will be replaced with '.'
     * </p>
     * @param alias the alias of the library
     * @since 7.4
     */
    Optional<Provider<MinimalExternalModuleDependency>> findLibrary(String alias);

    /**
     * Returns the provider for the corresponding bundle alias.
     * <p>
     * Note: Bundle will be automatically normalized: '-', '_' and '.' will be replaced with '.'