ImmutableList.Builder::add,
          ImmutableList.Builder::combine,
          ImmutableList.Builder::build);

  private static final Collector<Object, ?, ImmutableSet<Object>> TO_IMMUTABLE_SET =
      Collector.of(
          ImmutableSet::builder,
          ImmutableSet.Builder::add,
          ImmutableSet.Builder::combine,
          ImmutableSet.Builder::build);

  @GwtIncompatible

		},
		cli.BoolFlag{
			Usage: "combine inline data",
			Name:  "combine",
		},
		cli.BoolFlag{
			Usage: "combine inline data across versions when size matches",
			Name:  "xver",
		},
	}

	app.Action = func(c *cli.Context) error {
		ndjson := c.Bool("ndjson")
		if c.Bool("data") && c.Bool("combine") {
			return errors.New("cannot combine --data and --combine")
		}
		// file / version / file

      .body(RealResponseBody(contentType, contentLength, cacheWritingSource.buffer()))
      .build()
  }

  companion object {
    /** Combines cached headers with a network headers as defined by RFC 7234, 4.3.4. */
    private fun combine(
      cachedHeaders: Headers,
      networkHeaders: Headers,
    ): Headers {
      val result = Headers.Builder()

      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;
      }
      crc0 = combine(0, crc0);
      crc0 = combine(crc0, crc1);
      crc0 = combine(crc0, crc2);
      crc0 = combine(crc0, crc3);
      while (bb.hasRemaining()) {
        crc0 = (crc0 >>> 8) ^ BYTE_TABLE[(bb.get() ^ crc0) & 0xFF];
      }
      finished = true;
    }

            }
        }

        return dr;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.dfs.DfsReferralDataInternal#combine(jcifs.DfsReferralData)
     */
    @Override
    public DfsReferralDataInternal combine ( DfsReferralData n ) {
        DfsReferralDataImpl dr = new DfsReferralDataImpl();
        dr.server = n.getServer();
        dr.share = n.getShare();

                }

                if (isCommentLine(line)) {
                    commentLines.add(line);
                    continue;
                }

                boolean combine = checkCombineLines(line);
                if (combine) {
                    line = line.substring(0, line.length() - 1);
                }
                valueLines.add(line);

    @Override
    public Builder<E> addAll(Iterator<? extends E> elements) {
      super.addAll(elements);
      return this;
    }

    @CanIgnoreReturnValue
    Builder<E> combine(Builder<E> builder) {
      super.combine(builder);
      return this;
    }

    @Override
    public ImmutableSortedSet<E> build() {
      return copyOfInternal(comparator, contents.iterator());
    }
  }

      super.orderEntriesByValue(valueComparator);
      return this;
    }

    @Override
    @CanIgnoreReturnValue
    Builder<K, V> combine(ImmutableMap.Builder<K, V> builder) {
      super.combine(builder);
      return this;
    }

    /**
     * Returns a newly-created immutable bimap. The iteration order of the returned bimap is the

   */
  public static HashCode combineOrdered(Iterable<HashCode> hashCodes) {
    Iterator<HashCode> iterator = hashCodes.iterator();
    checkArgument(iterator.hasNext(), "Must be at least 1 hash code to combine.");
    int bits = iterator.next().bits();
    byte[] resultBytes = new byte[bits / 8];
    for (HashCode hashCode : hashCodes) {
      byte[] nextBytes = hashCode.asBytes();
      checkArgument(

      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);
      }
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> other) {
      super.combine(other);
      return this;
    }

    @Override
    public Builder<K, V> orderEntriesByValue(Comparator<? super V> valueComparator) {