type BaseAddress struct {
	ptr *Value
	idx *Value
}

// splitPtr returns the base address of ptr and any
// constant offset from that base.
// BaseAddress{ptr,nil},0 is always a valid result, but splitPtr
// tries to peel away as many constants into off as possible.
func splitPtr(ptr *Value) (BaseAddress, int64) {
	var idx *Value
	var off int64
	for {
		if ptr.Op == OpOffPtr {

 *
 * <p><b>Warning:</b> Splitter instances are immutable. Invoking a configuration method has no
 * effect on the receiving instance; you must store and use the new splitter instance it returns
 * instead.
 *
 * <pre>{@code
 * // Do NOT do this
 * Splitter splitter = Splitter.on('/');
 * splitter.trimResults(); // does nothing!
 * return splitter.split("wrong / wrong / wrong");
 * }</pre>
 *

 *
 * <p><b>Warning:</b> Splitter instances are immutable. Invoking a configuration method has no
 * effect on the receiving instance; you must store and use the new splitter instance it returns
 * instead.
 *
 * <pre>{@code
 * // Do NOT do this
 * Splitter splitter = Splitter.on('/');
 * splitter.trimResults(); // does nothing!
 * return splitter.split("wrong / wrong / wrong");
 * }</pre>
 *

                <UIState>
                    <splitter-proportions>
                        <SplitterProportionsDataImpl/>
                    </splitter-proportions>
                    <settings/>
                </UIState>
            </state>
            <state key="Copyright.UI">
                <UIState>
                    <splitter-proportions>
                        <SplitterProportionsDataImpl/>

       */
      if (!field.isSynthetic() && field.getType() == String.class) {
        builder.add(field);
      }
    }
    return builder.build();
  }

  private static final Splitter SPLITTER = Splitter.on('_');
  private static final Joiner JOINER = Joiner.on('-');

  private static String upperToHttpHeaderName(
      String constantName,
      ImmutableBiMap<String, String> specialCases,

import com.google.common.base.CharMatcher;
import com.google.common.base.Splitter;

import java.util.List;

public class PatternMatcherFactory {

    private static final EndOfPathMatcher END_OF_PATH_MATCHER = new EndOfPathMatcher();
    private static final Splitter PATH_SPLITTER = Splitter.on(CharMatcher.anyOf("\\/")).omitEmptyStrings();

      Spliterator<? extends T> splitr = stream.spliterator();
      splitrsBuilder.add(splitr);
      characteristics &= splitr.characteristics();
      estimatedSize = LongMath.saturatedAdd(estimatedSize, splitr.estimateSize());
    }
    return StreamSupport.stream(
            CollectSpliterators.flatMap(
                splitrsBuilder.build().spliterator(),
                splitr -> (Spliterator<T>) splitr,

absl::Status WriteSavedModel(SavedModel* saved_model_proto,
                             const std::string& file_prefix) {
#if !defined(PLATFORM_WINDOWS) && !defined(__APPLE__)
  tools::proto_splitter::SavedModelSplitter splitter(saved_model_proto);
  return splitter.Write(file_prefix);
#else
  return absl::UnimplementedError(
      "WriteSavedModel not implemented for Windows or MacOS.");
#endif
}

            if (prefix.isEmpty()) {
                return deduplicatedName;
            }

            Splitter splitter = Splitter.on('-').omitEmptyStrings();
            List<String> prefixParts = Lists.newArrayList(splitter.split(prefix));
            List<String> postfixParts = Lists.newArrayList(splitter.split(originalName));
            List<String> words = new ArrayList<>();

            if (postfixParts.size() > 1) {

            .splitToList(alias)
            .stream()
            .map(StringUtils::capitalize)
            .collect(Collectors.joining());
    }

    protected static Splitter nameSplitter() {
        return Splitter.on(SEPARATOR_PATTERN);
    }

    protected void addImport(Class<?> clazz) throws IOException {
        addImport(clazz.getCanonicalName());
    }