148                                            boolean isParallel) {

   148                                            boolean isParallel) {

   149         return new StreamSpliterators.IntWrappingSpliterator<>(ph, supplier, isParallel);

   149         return new StreamSpliterators.IntWrappingSpliterator<>(ph, supplier, isParallel);

   150     }

   150     }

   151 

   151 

   152     @Override

   152     @Override

   153     final Spliterator.OfInt lazySpliterator(Supplier<? extends Spliterator<Integer>> supplier) {

   154     final Spliterator.OfInt lazySpliterator(Supplier<? extends Spliterator<Integer>> supplier) {

   154         return new StreamSpliterators.DelegatingSpliterator.OfInt((Supplier<Spliterator.OfInt>) supplier);

   155         return new StreamSpliterators.DelegatingSpliterator.OfInt((Supplier<Spliterator.OfInt>) supplier);

   155     }

   156     }

   156 

   157 

   157     @Override

   158     @Override

   188                                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   189                                                      StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   189             @Override

   190             @Override

   190             Sink<Integer> opWrapSink(int flags, Sink<Long> sink) {

   191             Sink<Integer> opWrapSink(int flags, Sink<Long> sink) {

   191                 return new Sink.ChainedInt(sink) {

   192                 return new Sink.ChainedInt(sink) {

   192                     @Override

   193                     @Override

   193                     public void accept(int t) {

   195                     public void accept(int t) {

   194                         downstream.accept((long) t);

   196                         downstream.accept((long) t);

   195                     }

   197                     }

   196                 };

   198                 };

   197             }

   199             }

   204                                                        StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   206                                                        StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   205             @Override

   207             @Override

   206             Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {

   208             Sink<Integer> opWrapSink(int flags, Sink<Double> sink) {

   207                 return new Sink.ChainedInt(sink) {

   209                 return new Sink.ChainedInt(sink) {

   208                     @Override

   210                     @Override

   209                     public void accept(int t) {

   212                     public void accept(int t) {

   210                         downstream.accept((double) t);

   213                         downstream.accept((double) t);

   211                     }

   214                     }

   212                 };

   215                 };

   213             }

   216             }

   243                                                              StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   246                                                              StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {

   244             @Override

   247             @Override

   245             Sink<Integer> opWrapSink(int flags, Sink<U> sink) {

   248             Sink<Integer> opWrapSink(int flags, Sink<U> sink) {

   246                 return new Sink.ChainedInt(sink) {

   249                 return new Sink.ChainedInt(sink) {

   247                     @Override

   250                     @Override

   248                     public void accept(int t) {

   252                     public void accept(int t) {

   249                         downstream.accept(mapper.apply(t));

   253                         downstream.accept(mapper.apply(t));

   250                     }

   254                     }

   251                 };

   255                 };

   252             }

   256             }