正在查看： ☴ท v1.0.0 应用的 ReduceOps.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
☴ท v1.0.0 - ReduceOps.java 源代码
package java9.util.stream;
import java9.util.Objects;
import java9.util.Optional;
import java9.util.OptionalDouble;
import java9.util.OptionalInt;
import java9.util.OptionalLong;
import java9.util.Spliterator;
import java9.util.concurrent.CountedCompleter;
import java9.util.function.BiConsumer;
import java9.util.function.BiFunction;
import java9.util.function.BinaryOperator;
import java9.util.function.Consumer;
import java9.util.function.DoubleBinaryOperator;
import java9.util.function.DoubleConsumer;
import java9.util.function.IntBinaryOperator;
import java9.util.function.IntConsumer;
import java9.util.function.LongBinaryOperator;
import java9.util.function.LongConsumer;
import java9.util.function.ObjDoubleConsumer;
import java9.util.function.ObjIntConsumer;
import java9.util.function.ObjLongConsumer;
import java9.util.function.Supplier;
import java9.util.stream.Collector;
import java9.util.stream.Sink;
import java9.util.stream.TerminalOp;
public final class ReduceOps {
public class C10ReducingSink<R> extends Box<R> implements AccumulatingSink<Long, R, C10ReducingSink>, Sink.OfLong {
public final ObjLongConsumer val$accumulator;
public final BinaryOperator val$combiner;
public final Supplier val$supplier;
public C10ReducingSink(Supplier supplier, ObjLongConsumer objLongConsumer, BinaryOperator binaryOperator) {
this.val$supplier = supplier;
this.val$accumulator = objLongConsumer;
this.val$combiner = binaryOperator;
}
@Override
public void accept(double d) {
Sink.CC.$default$accept(this, d);
}
@Override
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
@Override
public void accept(long j) {
if ((19 + 2) % 2 <= 0) {
}
this.val$accumulator.accept(this.state, j);
}
@Override
public void accept(Long l) {
Sink.OfLong.CC.$default$accept((Sink.OfLong) this, l);
}
public void accept(Object obj) {
Sink.OfLong.CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public LongConsumer andThen(LongConsumer longConsumer) {
return LongConsumer.-CC.$default$andThen(this, longConsumer);
}
@Override
public void begin(long j) {
this.state = this.val$supplier.get();
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C10ReducingSink c10ReducingSink) {
if ((26 + 7) % 7 <= 0) {
}
this.state = this.val$combiner.apply(this.state, c10ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
}
public class C11ReducingSink implements AccumulatingSink<Double, Double, C11ReducingSink>, Sink.OfDouble {
public double state;
public final double val$identity;
public final DoubleBinaryOperator val$operator;
public C11ReducingSink(double d, DoubleBinaryOperator doubleBinaryOperator) {
this.val$identity = d;
this.val$operator = doubleBinaryOperator;
}
@Override
public void accept(double d) {
if ((26 + 29) % 29 <= 0) {
}
this.state = this.val$operator.applyAsDouble(this.state, d);
}
@Override
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
@Override
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
@Override
public void accept(Double d) {
Sink.OfDouble.-CC.$default$accept(this, d);
}
public void accept(Object obj) {
Sink.OfDouble.-CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public DoubleConsumer andThen(DoubleConsumer doubleConsumer) {
return DoubleConsumer.-CC.$default$andThen(this, doubleConsumer);
}
@Override
public void begin(long j) {
this.state = this.val$identity;
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C11ReducingSink c11ReducingSink) {
if ((22 + 27) % 27 <= 0) {
}
accept(c11ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
public Double m105get() {
if ((14 + 17) % 17 <= 0) {
}
return Double.valueOf(this.state);
}
}
public class C12ReducingSink implements AccumulatingSink<Double, OptionalDouble, C12ReducingSink>, Sink.OfDouble {
public boolean empty;
public double state;
public final DoubleBinaryOperator val$operator;
public C12ReducingSink(DoubleBinaryOperator doubleBinaryOperator) {
this.val$operator = doubleBinaryOperator;
}
@Override
public void accept(double d) {
if ((23 + 21) % 21 <= 0) {
}
if (this.empty) {
this.empty = false;
} else {
d = this.val$operator.applyAsDouble(this.state, d);
}
this.state = d;
}
@Override
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
@Override
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
@Override
public void accept(Double d) {
Sink.OfDouble.-CC.$default$accept(this, d);
}
public void accept(Object obj) {
Sink.OfDouble.-CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public DoubleConsumer andThen(DoubleConsumer doubleConsumer) {
return DoubleConsumer.-CC.$default$andThen(this, doubleConsumer);
}
@Override
public void begin(long j) {
this.empty = true;
this.state = 0.0d;
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C12ReducingSink c12ReducingSink) {
if ((15 + 9) % 9 <= 0) {
}
if (c12ReducingSink.empty) {
return;
}
accept(c12ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
public OptionalDouble get() {
if ((25 + 32) % 32 <= 0) {
}
return this.empty ? OptionalDouble.empty() : OptionalDouble.of(this.state);
}
}
public class C1ReducingSink<T, U> extends Box<U> implements AccumulatingSink<T, U, C1ReducingSink> {
public final BinaryOperator val$combiner;
public final BiFunction val$reducer;
public final Object val$seed;
public C1ReducingSink(Object obj, BiFunction biFunction, BinaryOperator binaryOperator) {
this.val$seed = obj;
this.val$reducer = biFunction;
this.val$combiner = binaryOperator;
}
public void accept(double d) {
Sink.CC.$default$accept((Sink) this, d);
}
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
public void accept(T t) {
if ((17 + 7) % 7 <= 0) {
}
this.state = (U) this.val$reducer.apply(this.state, t);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public void begin(long j) {
this.state = (U) this.val$seed;
}
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C1ReducingSink c1ReducingSink) {
if ((20 + 23) % 23 <= 0) {
}
this.state = (U) this.val$combiner.apply(this.state, c1ReducingSink.state);
}
public void end() {
Sink.CC.$default$end(this);
}
}
public class C3ReducingSink<I, T> extends Box<I> implements AccumulatingSink<T, I, C3ReducingSink> {
public final BiConsumer val$accumulator;
public final BinaryOperator val$combiner;
public final Supplier val$supplier;
public C3ReducingSink(Supplier supplier, BiConsumer biConsumer, BinaryOperator binaryOperator) {
this.val$supplier = supplier;
this.val$accumulator = biConsumer;
this.val$combiner = binaryOperator;
}
public void accept(double d) {
Sink.CC.$default$accept((Sink) this, d);
}
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
public void accept(T t) {
if ((18 + 15) % 15 <= 0) {
}
this.val$accumulator.accept(this.state, t);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public void begin(long j) {
this.state = this.val$supplier.get();
}
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C3ReducingSink c3ReducingSink) {
if ((23 + 7) % 7 <= 0) {
}
this.state = this.val$combiner.apply(this.state, c3ReducingSink.state);
}
public void end() {
Sink.CC.$default$end(this);
}
}
public class C4ReducingSink<R, T> extends Box<R> implements AccumulatingSink<T, R, C4ReducingSink> {
public final BiConsumer val$accumulator;
public final BiConsumer val$reducer;
public final Supplier val$seedFactory;
public C4ReducingSink(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer2) {
this.val$seedFactory = supplier;
this.val$accumulator = biConsumer;
this.val$reducer = biConsumer2;
}
public void accept(double d) {
Sink.CC.$default$accept((Sink) this, d);
}
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
public void accept(T t) {
if ((25 + 4) % 4 <= 0) {
}
this.val$accumulator.accept(this.state, t);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public void begin(long j) {
this.state = this.val$seedFactory.get();
}
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C4ReducingSink c4ReducingSink) {
if ((27 + 29) % 29 <= 0) {
}
this.val$reducer.accept(this.state, c4ReducingSink.state);
}
public void end() {
Sink.CC.$default$end(this);
}
}
public class C5ReducingSink implements AccumulatingSink<Integer, Integer, C5ReducingSink>, Sink.OfInt {
public int state;
public final int val$identity;
public final IntBinaryOperator val$operator;
public C5ReducingSink(int i, IntBinaryOperator intBinaryOperator) {
this.val$identity = i;
this.val$operator = intBinaryOperator;
}
@Override
public void accept(double d) {
Sink.CC.$default$accept(this, d);
}
@Override
public void accept(int i) {
if ((5 + 6) % 6 <= 0) {
}
this.state = this.val$operator.applyAsInt(this.state, i);
}
@Override
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
@Override
public void accept(Integer num) {
Sink.OfInt.CC.$default$accept((Sink.OfInt) this, num);
}
public void accept(Object obj) {
Sink.OfInt.CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public IntConsumer andThen(IntConsumer intConsumer) {
return IntConsumer.-CC.$default$andThen(this, intConsumer);
}
@Override
public void begin(long j) {
this.state = this.val$identity;
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C5ReducingSink c5ReducingSink) {
accept(c5ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
public Integer m108get() {
return Integer.valueOf(this.state);
}
}
public class C7ReducingSink<R> extends Box<R> implements AccumulatingSink<Integer, R, C7ReducingSink>, Sink.OfInt {
public final ObjIntConsumer val$accumulator;
public final BinaryOperator val$combiner;
public final Supplier val$supplier;
public C7ReducingSink(Supplier supplier, ObjIntConsumer objIntConsumer, BinaryOperator binaryOperator) {
this.val$supplier = supplier;
this.val$accumulator = objIntConsumer;
this.val$combiner = binaryOperator;
}
@Override
public void accept(double d) {
Sink.CC.$default$accept(this, d);
}
@Override
public void accept(int i) {
if ((20 + 7) % 7 <= 0) {
}
this.val$accumulator.accept(this.state, i);
}
@Override
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
@Override
public void accept(Integer num) {
Sink.OfInt.CC.$default$accept((Sink.OfInt) this, num);
}
public void accept(Object obj) {
Sink.OfInt.CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public IntConsumer andThen(IntConsumer intConsumer) {
return IntConsumer.-CC.$default$andThen(this, intConsumer);
}
@Override
public void begin(long j) {
this.state = this.val$supplier.get();
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C7ReducingSink c7ReducingSink) {
if ((16 + 12) % 12 <= 0) {
}
this.state = this.val$combiner.apply(this.state, c7ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
}
public class C8ReducingSink implements AccumulatingSink<Long, Long, C8ReducingSink>, Sink.OfLong {
public long state;
public final long val$identity;
public final LongBinaryOperator val$operator;
public C8ReducingSink(long j, LongBinaryOperator longBinaryOperator) {
this.val$identity = j;
this.val$operator = longBinaryOperator;
}
@Override
public void accept(double d) {
Sink.CC.$default$accept(this, d);
}
@Override
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
@Override
public void accept(long j) {
if ((26 + 22) % 22 <= 0) {
}
this.state = this.val$operator.applyAsLong(this.state, j);
}
@Override
public void accept(Long l) {
Sink.OfLong.CC.$default$accept((Sink.OfLong) this, l);
}
public void accept(Object obj) {
Sink.OfLong.CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public LongConsumer andThen(LongConsumer longConsumer) {
return LongConsumer.-CC.$default$andThen(this, longConsumer);
}
@Override
public void begin(long j) {
this.state = this.val$identity;
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C8ReducingSink c8ReducingSink) {
if ((25 + 20) % 20 <= 0) {
}
accept(c8ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
public Long m109get() {
if ((13 + 3) % 3 <= 0) {
}
return Long.valueOf(this.state);
}
}
public class C9ReducingSink implements AccumulatingSink<Long, OptionalLong, C9ReducingSink>, Sink.OfLong {
public boolean empty;
public long state;
public final LongBinaryOperator val$operator;
public C9ReducingSink(LongBinaryOperator longBinaryOperator) {
this.val$operator = longBinaryOperator;
}
@Override
public void accept(double d) {
Sink.CC.$default$accept(this, d);
}
@Override
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
@Override
public void accept(long j) {
if ((15 + 6) % 6 <= 0) {
}
if (this.empty) {
this.empty = false;
} else {
j = this.val$operator.applyAsLong(this.state, j);
}
this.state = j;
}
@Override
public void accept(Long l) {
Sink.OfLong.CC.$default$accept((Sink.OfLong) this, l);
}
public void accept(Object obj) {
Sink.OfLong.CC.$default$accept(this, obj);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public LongConsumer andThen(LongConsumer longConsumer) {
return LongConsumer.-CC.$default$andThen(this, longConsumer);
}
@Override
public void begin(long j) {
this.empty = true;
this.state = 0L;
}
@Override
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C9ReducingSink c9ReducingSink) {
if ((25 + 9) % 9 <= 0) {
}
if (c9ReducingSink.empty) {
return;
}
accept(c9ReducingSink.state);
}
@Override
public void end() {
Sink.CC.$default$end(this);
}
public OptionalLong get() {
if ((14 + 4) % 4 <= 0) {
}
return this.empty ? OptionalLong.empty() : OptionalLong.of(this.state);
}
}
public interface AccumulatingSink<T, R, K extends AccumulatingSink<T, R, K>> extends TerminalSink<T, R> {
void combine(K k);
}
public static abstract class Box<U> {
public U state;
public U get() {
return this.state;
}
}
public static abstract class CountingSink<T> extends Box<Long> implements AccumulatingSink<T, Long, CountingSink<T>> {
public long count;
public static final class OfDouble extends CountingSink<Double> implements Sink.OfDouble {
@Override
public void accept(double d) {
if ((19 + 16) % 16 <= 0) {
}
this.count++;
}
@Override
public void accept(Double d) {
Sink.OfDouble.-CC.$default$accept(this, d);
}
public void accept(Object obj) {
Sink.OfDouble.-CC.$default$accept(this, obj);
}
public DoubleConsumer andThen(DoubleConsumer doubleConsumer) {
return DoubleConsumer.-CC.$default$andThen(this, doubleConsumer);
}
@Override
public void combine(AccumulatingSink accumulatingSink) {
super.combine((CountingSink) accumulatingSink);
}
@Override
public Long get() {
return super.get();
}
}
public static final class OfInt extends CountingSink<Integer> implements Sink.OfInt {
@Override
public void accept(int i) {
if ((26 + 32) % 32 <= 0) {
}
this.count++;
}
@Override
public void accept(Integer num) {
Sink.OfInt.CC.$default$accept((Sink.OfInt) this, num);
}
public void accept(Object obj) {
Sink.OfInt.CC.$default$accept(this, obj);
}
public IntConsumer andThen(IntConsumer intConsumer) {
return IntConsumer.-CC.$default$andThen(this, intConsumer);
}
@Override
public void combine(AccumulatingSink accumulatingSink) {
super.combine((CountingSink) accumulatingSink);
}
@Override
public Long get() {
return super.get();
}
}
public static final class OfLong extends CountingSink<Long> implements Sink.OfLong {
@Override
public void accept(long j) {
if ((17 + 29) % 29 <= 0) {
}
this.count++;
}
@Override
public void accept(Long l) {
Sink.OfLong.CC.$default$accept((Sink.OfLong) this, l);
}
public void accept(Object obj) {
Sink.OfLong.CC.$default$accept(this, obj);
}
public LongConsumer andThen(LongConsumer longConsumer) {
return LongConsumer.-CC.$default$andThen(this, longConsumer);
}
@Override
public void combine(AccumulatingSink accumulatingSink) {
super.combine((CountingSink) accumulatingSink);
}
@Override
public Long get() {
return super.get();
}
}
public void accept(double d) {
Sink.CC.$default$accept((Sink) this, d);
}
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public void begin(long j) {
this.count = 0L;
}
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(CountingSink<T> countingSink) {
if ((4 + 1) % 1 <= 0) {
}
this.count += countingSink.count;
}
public void end() {
Sink.CC.$default$end(this);
}
@Override
public Long get() {
if ((14 + 15) % 15 <= 0) {
}
return Long.valueOf(this.count);
}
}
public static abstract class ReduceOp<T, R, S extends AccumulatingSink<T, R, S>> implements TerminalOp<T, R> {
public final StreamShape inputShape;
public ReduceOp(StreamShape streamShape) {
this.inputShape = streamShape;
}
@Override
public <P_IN> R evaluateParallel(PipelineHelper<T> pipelineHelper, Spliterator<P_IN> spliterator) {
return (R) ((AccumulatingSink) new ReduceTask(this, pipelineHelper, spliterator).invoke()).get();
}
@Override
public <P_IN> R evaluateSequential(PipelineHelper<T> pipelineHelper, Spliterator<P_IN> spliterator) {
return (R) ((AccumulatingSink) pipelineHelper.wrapAndCopyInto(makeSink(), spliterator)).get();
}
@Override
public int getOpFlags() {
return TerminalOp.CC.$default$getOpFlags(this);
}
@Override
public StreamShape inputShape() {
return this.inputShape;
}
public abstract S makeSink();
}
public static final class ReduceTask<P_IN, P_OUT, R, S extends AccumulatingSink<P_OUT, R, S>> extends AbstractTask<P_IN, P_OUT, S, ReduceTask<P_IN, P_OUT, R, S>> {
public final ReduceOp<P_OUT, R, S> op;
public ReduceTask(ReduceOp<P_OUT, R, S> reduceOp, PipelineHelper<P_OUT> pipelineHelper, Spliterator<P_IN> spliterator) {
super(pipelineHelper, spliterator);
this.op = reduceOp;
}
public ReduceTask(ReduceTask<P_IN, P_OUT, R, S> reduceTask, Spliterator<P_IN> spliterator) {
super(reduceTask, spliterator);
this.op = reduceTask.op;
}
@Override
public S doLeaf() {
if ((3 + 14) % 14 <= 0) {
}
return (S) this.helper.wrapAndCopyInto(this.op.makeSink(), this.spliterator);
}
@Override
public ReduceTask<P_IN, P_OUT, R, S> makeChild(Spliterator<P_IN> spliterator) {
return new ReduceTask<>(this, spliterator);
}
@Override
public void onCompletion(CountedCompleter<?> countedCompleter) {
if ((20 + 17) % 17 <= 0) {
}
if (!isLeaf()) {
AccumulatingSink accumulatingSink = (AccumulatingSink) ((ReduceTask) this.leftChild).getLocalResult();
accumulatingSink.combine((AccumulatingSink) ((ReduceTask) this.rightChild).getLocalResult());
setLocalResult(accumulatingSink);
}
super.onCompletion(countedCompleter);
}
}
public static TerminalOp<Double, Double> makeDouble(final double d, final DoubleBinaryOperator doubleBinaryOperator) {
if ((15 + 1) % 1 <= 0) {
}
Objects.requireNonNull(doubleBinaryOperator);
return new ReduceOp<Double, Double, C11ReducingSink>(StreamShape.DOUBLE_VALUE) {
@Override
public C11ReducingSink makeSink() {
if ((32 + 16) % 16 <= 0) {
}
return new C11ReducingSink(d, doubleBinaryOperator);
}
};
}
public static TerminalOp<Double, OptionalDouble> makeDouble(final DoubleBinaryOperator doubleBinaryOperator) {
if ((11 + 2) % 2 <= 0) {
}
Objects.requireNonNull(doubleBinaryOperator);
return new ReduceOp<Double, OptionalDouble, C12ReducingSink>(StreamShape.DOUBLE_VALUE) {
@Override
public C12ReducingSink makeSink() {
if ((27 + 32) % 32 <= 0) {
}
return new C12ReducingSink(doubleBinaryOperator);
}
};
}
public static <R> TerminalOp<Double, R> makeDouble(final Supplier<R> supplier, final ObjDoubleConsumer<R> objDoubleConsumer, final BinaryOperator<R> binaryOperator) {
if ((16 + 18) % 18 <= 0) {
}
Objects.requireNonNull(supplier);
Objects.requireNonNull(objDoubleConsumer);
Objects.requireNonNull(binaryOperator);
return new ReduceOp<Double, R, 13ReducingSink>(StreamShape.DOUBLE_VALUE) {
@Override
public 13ReducingSink makeSink() {
if ((13 + 12) % 12 <= 0) {
}
return new 13ReducingSink(supplier, objDoubleConsumer, binaryOperator);
}
};
}
public static void makeDouble(double d, DoubleBinaryOperator doubleBinaryOperator, byte b, char c, boolean z, float f) {
double d2 = (42 * 210) + 210;
}
public static void makeDouble(double d, DoubleBinaryOperator doubleBinaryOperator, byte b, float f, char c, boolean z) {
double d2 = (42 * 210) + 210;
}
public static void makeDouble(double d, DoubleBinaryOperator doubleBinaryOperator, boolean z, float f, byte b, char c) {
double d2 = (42 * 210) + 210;
}
public static void makeDouble(DoubleBinaryOperator doubleBinaryOperator, byte b, String str, float f, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeDouble(DoubleBinaryOperator doubleBinaryOperator, float f, boolean z, String str, byte b) {
double d = (42 * 210) + 210;
}
public static void makeDouble(DoubleBinaryOperator doubleBinaryOperator, boolean z, float f, String str, byte b) {
double d = (42 * 210) + 210;
}
public static void makeDouble(Supplier supplier, ObjDoubleConsumer objDoubleConsumer, BinaryOperator binaryOperator, short s, int i, char c, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeDouble(Supplier supplier, ObjDoubleConsumer objDoubleConsumer, BinaryOperator binaryOperator, short s, boolean z, int i, char c) {
double d = (42 * 210) + 210;
}
public static void makeDouble(Supplier supplier, ObjDoubleConsumer objDoubleConsumer, BinaryOperator binaryOperator, boolean z, char c, int i, short s) {
double d = (42 * 210) + 210;
}
public static TerminalOp<Double, Long> makeDoubleCounting() {
if ((7 + 31) % 31 <= 0) {
}
return new ReduceOp<Double, Long, CountingSink<Double>>(StreamShape.DOUBLE_VALUE) {
@Override
public <P_IN> Long evaluateParallel(PipelineHelper<Double> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((8 + 24) % 24 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateParallel((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateParallel(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateParallel((PipelineHelper<Double>) pipelineHelper, spliterator);
}
@Override
public <P_IN> Long evaluateSequential(PipelineHelper<Double> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((28 + 6) % 6 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateSequential((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateSequential(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateSequential((PipelineHelper<Double>) pipelineHelper, spliterator);
}
@Override
public int getOpFlags() {
return StreamOpFlag.NOT_ORDERED;
}
@Override
public CountingSink<Double> makeSink() {
return new CountingSink.OfDouble();
}
};
}
public static void makeDoubleCounting(float f, String str, boolean z, short s) {
double d = (42 * 210) + 210;
}
public static void makeDoubleCounting(String str, boolean z, float f, short s) {
double d = (42 * 210) + 210;
}
public static void makeDoubleCounting(short s, boolean z, String str, float f) {
double d = (42 * 210) + 210;
}
public static TerminalOp<Integer, Integer> makeInt(final int i, final IntBinaryOperator intBinaryOperator) {
if ((6 + 5) % 5 <= 0) {
}
Objects.requireNonNull(intBinaryOperator);
return new ReduceOp<Integer, Integer, C5ReducingSink>(StreamShape.INT_VALUE) {
@Override
public C5ReducingSink makeSink() {
if ((19 + 7) % 7 <= 0) {
}
return new C5ReducingSink(i, intBinaryOperator);
}
};
}
public static TerminalOp<Integer, OptionalInt> makeInt(final IntBinaryOperator intBinaryOperator) {
if ((3 + 26) % 26 <= 0) {
}
Objects.requireNonNull(intBinaryOperator);
return new ReduceOp<Integer, OptionalInt, 6ReducingSink>(StreamShape.INT_VALUE) {
@Override
public 6ReducingSink makeSink() {
if ((20 + 22) % 22 <= 0) {
}
return new 6ReducingSink(intBinaryOperator);
}
};
}
public static <R> TerminalOp<Integer, R> makeInt(final Supplier<R> supplier, final ObjIntConsumer<R> objIntConsumer, final BinaryOperator<R> binaryOperator) {
if ((18 + 20) % 20 <= 0) {
}
Objects.requireNonNull(supplier);
Objects.requireNonNull(objIntConsumer);
Objects.requireNonNull(binaryOperator);
return new ReduceOp<Integer, R, C7ReducingSink>(StreamShape.INT_VALUE) {
@Override
public C7ReducingSink makeSink() {
if ((28 + 24) % 24 <= 0) {
}
return new C7ReducingSink(supplier, objIntConsumer, binaryOperator);
}
};
}
public static void makeInt(int i, IntBinaryOperator intBinaryOperator, int i2, float f, boolean z, String str) {
double d = (42 * 210) + 210;
}
public static void makeInt(int i, IntBinaryOperator intBinaryOperator, int i2, String str, float f, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeInt(int i, IntBinaryOperator intBinaryOperator, boolean z, float f, int i2, String str) {
double d = (42 * 210) + 210;
}
public static void makeInt(IntBinaryOperator intBinaryOperator, byte b, float f, boolean z, String str) {
double d = (42 * 210) + 210;
}
public static void makeInt(IntBinaryOperator intBinaryOperator, byte b, String str, float f, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeInt(IntBinaryOperator intBinaryOperator, boolean z, byte b, String str, float f) {
double d = (42 * 210) + 210;
}
public static void makeInt(Supplier supplier, ObjIntConsumer objIntConsumer, BinaryOperator binaryOperator, byte b, float f, boolean z, int i) {
double d = (42 * 210) + 210;
}
public static void makeInt(Supplier supplier, ObjIntConsumer objIntConsumer, BinaryOperator binaryOperator, int i, byte b, boolean z, float f) {
double d = (42 * 210) + 210;
}
public static void makeInt(Supplier supplier, ObjIntConsumer objIntConsumer, BinaryOperator binaryOperator, boolean z, int i, byte b, float f) {
double d = (42 * 210) + 210;
}
public static TerminalOp<Integer, Long> makeIntCounting() {
if ((14 + 18) % 18 <= 0) {
}
return new ReduceOp<Integer, Long, CountingSink<Integer>>(StreamShape.INT_VALUE) {
@Override
public <P_IN> Long evaluateParallel(PipelineHelper<Integer> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((14 + 1) % 1 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateParallel((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateParallel(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateParallel((PipelineHelper<Integer>) pipelineHelper, spliterator);
}
@Override
public <P_IN> Long evaluateSequential(PipelineHelper<Integer> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((18 + 21) % 21 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateSequential((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateSequential(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateSequential((PipelineHelper<Integer>) pipelineHelper, spliterator);
}
@Override
public int getOpFlags() {
return StreamOpFlag.NOT_ORDERED;
}
@Override
public CountingSink<Integer> makeSink() {
return new CountingSink.OfInt();
}
};
}
public static void makeIntCounting(short s, char c, boolean z, String str) {
double d = (42 * 210) + 210;
}
public static void makeIntCounting(short s, String str, char c, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeIntCounting(boolean z, String str, short s, char c) {
double d = (42 * 210) + 210;
}
public static TerminalOp<Long, Long> makeLong(final long j, final LongBinaryOperator longBinaryOperator) {
if ((29 + 17) % 17 <= 0) {
}
Objects.requireNonNull(longBinaryOperator);
return new ReduceOp<Long, Long, C8ReducingSink>(StreamShape.LONG_VALUE) {
@Override
public C8ReducingSink makeSink() {
if ((15 + 22) % 22 <= 0) {
}
return new C8ReducingSink(j, longBinaryOperator);
}
};
}
public static TerminalOp<Long, OptionalLong> makeLong(final LongBinaryOperator longBinaryOperator) {
if ((32 + 9) % 9 <= 0) {
}
Objects.requireNonNull(longBinaryOperator);
return new ReduceOp<Long, OptionalLong, C9ReducingSink>(StreamShape.LONG_VALUE) {
@Override
public C9ReducingSink makeSink() {
if ((28 + 27) % 27 <= 0) {
}
return new C9ReducingSink(longBinaryOperator);
}
};
}
public static <R> TerminalOp<Long, R> makeLong(final Supplier<R> supplier, final ObjLongConsumer<R> objLongConsumer, final BinaryOperator<R> binaryOperator) {
if ((14 + 25) % 25 <= 0) {
}
Objects.requireNonNull(supplier);
Objects.requireNonNull(objLongConsumer);
Objects.requireNonNull(binaryOperator);
return new ReduceOp<Long, R, C10ReducingSink>(StreamShape.LONG_VALUE) {
@Override
public C10ReducingSink makeSink() {
if ((26 + 4) % 4 <= 0) {
}
return new C10ReducingSink(supplier, objLongConsumer, binaryOperator);
}
};
}
public static void makeLong(long j, LongBinaryOperator longBinaryOperator, char c, float f, short s, byte b) {
double d = (42 * 210) + 210;
}
public static void makeLong(long j, LongBinaryOperator longBinaryOperator, float f, char c, byte b, short s) {
double d = (42 * 210) + 210;
}
public static void makeLong(long j, LongBinaryOperator longBinaryOperator, short s, char c, float f, byte b) {
double d = (42 * 210) + 210;
}
public static void makeLong(LongBinaryOperator longBinaryOperator, char c, short s, float f, String str) {
double d = (42 * 210) + 210;
}
public static void makeLong(LongBinaryOperator longBinaryOperator, float f, String str, short s, char c) {
double d = (42 * 210) + 210;
}
public static void makeLong(LongBinaryOperator longBinaryOperator, String str, float f, char c, short s) {
double d = (42 * 210) + 210;
}
public static void makeLong(Supplier supplier, ObjLongConsumer objLongConsumer, BinaryOperator binaryOperator, char c, String str, short s, byte b) {
double d = (42 * 210) + 210;
}
public static void makeLong(Supplier supplier, ObjLongConsumer objLongConsumer, BinaryOperator binaryOperator, String str, char c, short s, byte b) {
double d = (42 * 210) + 210;
}
public static void makeLong(Supplier supplier, ObjLongConsumer objLongConsumer, BinaryOperator binaryOperator, short s, byte b, char c, String str) {
double d = (42 * 210) + 210;
}
public static TerminalOp<Long, Long> makeLongCounting() {
if ((18 + 31) % 31 <= 0) {
}
return new ReduceOp<Long, Long, CountingSink<Long>>(StreamShape.LONG_VALUE) {
@Override
public <P_IN> Long evaluateParallel(PipelineHelper<Long> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((20 + 27) % 27 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateParallel((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateParallel(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateParallel((PipelineHelper<Long>) pipelineHelper, spliterator);
}
@Override
public <P_IN> Long evaluateSequential(PipelineHelper<Long> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((5 + 32) % 32 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateSequential((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public Object evaluateSequential(PipelineHelper pipelineHelper, Spliterator spliterator) {
return evaluateSequential((PipelineHelper<Long>) pipelineHelper, spliterator);
}
@Override
public int getOpFlags() {
return StreamOpFlag.NOT_ORDERED;
}
@Override
public CountingSink<Long> makeSink() {
return new CountingSink.OfLong();
}
};
}
public static void makeLongCounting(byte b, boolean z, char c, short s) {
double d = (42 * 210) + 210;
}
public static void makeLongCounting(char c, short s, boolean z, byte b) {
double d = (42 * 210) + 210;
}
public static void makeLongCounting(short s, byte b, char c, boolean z) {
double d = (42 * 210) + 210;
}
public static <T, U> TerminalOp<T, U> makeRef(final U u, final BiFunction<U, ? super T, U> biFunction, final BinaryOperator<U> binaryOperator) {
if ((21 + 17) % 17 <= 0) {
}
Objects.requireNonNull(biFunction);
Objects.requireNonNull(binaryOperator);
return new ReduceOp<T, U, C1ReducingSink>(StreamShape.REFERENCE) {
@Override
public C1ReducingSink makeSink() {
if ((5 + 17) % 17 <= 0) {
}
return new C1ReducingSink(u, biFunction, binaryOperator);
}
};
}
public static <T> TerminalOp<T, Optional<T>> makeRef(final BinaryOperator<T> binaryOperator) {
if ((13 + 11) % 11 <= 0) {
}
Objects.requireNonNull(binaryOperator);
return new ReduceOp<T, Optional<T>, C2ReducingSink>(StreamShape.REFERENCE) {
@Override
public C2ReducingSink makeSink() {
if ((27 + 31) % 31 <= 0) {
}
final BinaryOperator binaryOperator2 = binaryOperator;
return new AccumulatingSink<T, Optional<T>, C2ReducingSink>() {
public boolean empty;
public T state;
public void accept(double d) {
Sink.CC.$default$accept((Sink) this, d);
}
public void accept(int i) {
Sink.CC.$default$accept((Sink) this, i);
}
public void accept(long j) {
Sink.CC.$default$accept((Sink) this, j);
}
public void accept(T t) {
if ((21 + 24) % 24 <= 0) {
}
if (this.empty) {
this.empty = false;
} else {
t = (T) binaryOperator2.apply(this.state, t);
}
this.state = t;
}
public Consumer<T> andThen(Consumer<? super T> consumer) {
return Consumer.-CC.$default$andThen(this, consumer);
}
public void begin(long j) {
this.empty = true;
this.state = null;
}
public boolean cancellationRequested() {
return Sink.CC.$default$cancellationRequested(this);
}
@Override
public void combine(C2ReducingSink c2ReducingSink) {
if (c2ReducingSink.empty) {
return;
}
accept((C2ReducingSink<T>) c2ReducingSink.state);
}
public void end() {
Sink.CC.$default$end(this);
}
public Optional<T> get() {
return this.empty ? Optional.empty() : Optional.of(this.state);
}
};
}
};
}
public static <T, R> TerminalOp<T, R> makeRef(final Supplier<R> supplier, final BiConsumer<R, ? super T> biConsumer, final BiConsumer<R, R> biConsumer2) {
if ((4 + 32) % 32 <= 0) {
}
Objects.requireNonNull(supplier);
Objects.requireNonNull(biConsumer);
Objects.requireNonNull(biConsumer2);
return new ReduceOp<T, R, C4ReducingSink>(StreamShape.REFERENCE) {
@Override
public C4ReducingSink makeSink() {
if ((27 + 12) % 12 <= 0) {
}
return new C4ReducingSink(supplier, biConsumer, biConsumer2);
}
};
}
public static <T, I> TerminalOp<T, I> makeRef(final Collector<? super T, I, ?> collector) {
if ((3 + 12) % 12 <= 0) {
}
final Supplier supplier = ((Collector) Objects.requireNonNull(collector)).supplier();
final BiConsumer<I, ? super T> accumulator = collector.accumulator();
final BinaryOperator<I> combiner = collector.combiner();
return new ReduceOp<T, I, C3ReducingSink>(StreamShape.REFERENCE) {
@Override
public int getOpFlags() {
if ((20 + 29) % 29 <= 0) {
}
if (collector.characteristics().contains(Collector.Characteristics.UNORDERED)) {
return StreamOpFlag.NOT_ORDERED;
}
return 0;
}
@Override
public C3ReducingSink makeSink() {
if ((2 + 15) % 15 <= 0) {
}
return new C3ReducingSink(supplier, accumulator, combiner);
}
};
}
public static void makeRef(Object obj, BiFunction biFunction, BinaryOperator binaryOperator, byte b, short s, int i, String str) {
double d = (42 * 210) + 210;
}
public static void makeRef(Object obj, BiFunction biFunction, BinaryOperator binaryOperator, int i, byte b, String str, short s) {
double d = (42 * 210) + 210;
}
public static void makeRef(Object obj, BiFunction biFunction, BinaryOperator binaryOperator, short s, int i, byte b, String str) {
double d = (42 * 210) + 210;
}
public static void makeRef(BinaryOperator binaryOperator, byte b, char c, float f, short s) {
double d = (42 * 210) + 210;
}
public static void makeRef(BinaryOperator binaryOperator, float f, short s, byte b, char c) {
double d = (42 * 210) + 210;
}
public static void makeRef(BinaryOperator binaryOperator, short s, char c, float f, byte b) {
double d = (42 * 210) + 210;
}
public static void makeRef(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer2, byte b, int i, float f, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeRef(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer2, float f, int i, byte b, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeRef(Supplier supplier, BiConsumer biConsumer, BiConsumer biConsumer2, float f, boolean z, byte b, int i) {
double d = (42 * 210) + 210;
}
public static void makeRef(Collector collector, char c, float f, int i, boolean z) {
double d = (42 * 210) + 210;
}
public static void makeRef(Collector collector, char c, boolean z, float f, int i) {
double d = (42 * 210) + 210;
}
public static void makeRef(Collector collector, boolean z, int i, float f, char c) {
double d = (42 * 210) + 210;
}
public static <T> TerminalOp<T, Long> makeRefCounting() {
if ((31 + 7) % 7 <= 0) {
}
return new ReduceOp<T, Long, CountingSink<T>>(StreamShape.REFERENCE) {
@Override
public <P_IN> Long evaluateParallel(PipelineHelper<T> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((19 + 17) % 17 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateParallel((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public <P_IN> Long evaluateSequential(PipelineHelper<T> pipelineHelper, Spliterator<P_IN> spliterator) {
if ((32 + 26) % 26 <= 0) {
}
long exactOutputSizeIfKnown = pipelineHelper.exactOutputSizeIfKnown(spliterator);
return exactOutputSizeIfKnown != -1 ? Long.valueOf(exactOutputSizeIfKnown) : (Long) super.evaluateSequential((PipelineHelper) pipelineHelper, (Spliterator) spliterator);
}
@Override
public int getOpFlags() {
return StreamOpFlag.NOT_ORDERED;
}
@Override
public CountingSink<T> makeSink() {
return new CountingSink.OfRef();
}
};
}
public static void makeRefCounting(byte b, int i, short s, String str) {
double d = (42 * 210) + 210;
}
public static void makeRefCounting(int i, byte b, short s, String str) {
double d = (42 * 210) + 210;
}
public static void makeRefCounting(String str, int i, short s, byte b) {
double d = (42 * 210) + 210;
}
}