1109                 int start = index;
1110                 index = mid;
1111                 return new LinesSpliterator(value, start, mid - start);
1112             }
1113             return null;
1114         }
1115 
1116         @Override
1117         public long estimateSize() {
1118             return fence - index + 1;
1119         }
1120 
1121         @Override
1122         public int characteristics() {
1123             return Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL;
1124         }
1125 
1126         static LinesSpliterator spliterator(byte[] value) {
1127             return new LinesSpliterator(value, 0, value.length >>> 1);
1128         }
1129 
1130         static LinesSpliterator spliterator(byte[] value, int leading, int trailing) {
1131             int length = value.length >>> 1;
1132             int left = 0;
1133             int index;
1134             for (int l = 0; l < leading; l++) {
1135                 index = skipBlankForward(value, left, length);
1136                 if (index == left) {
1137                     break;
1138                 }
1139                 left = index;
1140             }
1141             int right = length;
1142             for (int t = 0; t < trailing; t++) {
1143                 index = skipBlankBackward(value, left, right);
1144                 if (index == right) {
1145                     break;
1146                 }
1147                 right = index;
1148             }
1149             return new LinesSpliterator(value, left, right - left);
1150         }
1151 
1152         private static int skipBlankForward(byte[] value, int start, int length) {
1153             int index = start;
1154             while (index < length) {
1155                 char ch = getChar(value, index++);
1156                 if (ch == '\n') {
1157                     return index;
1158                 }
1159                 if (ch == '\r') {
1160                     if (index < length && getChar(value, index) == '\n') {
1161                         return index + 1;
1162                     }
1163                     return index;
1164                 }
1165                 if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
1166                     return start;
1167                 }
1168             }
1169             return length;
1170         }
1171 
1172         private static int skipBlankBackward(byte[] value, int start, int fence) {
1173             int index = fence;
1174             if (start < index && getChar(value, index - 1) == '\n') {
1175                 index--;
1176             }
1177             if (start < index && getChar(value, index - 1) == '\r') {
1178                 index--;
1179             }
1180             while (start < index) {
1181                 char ch = getChar(value, --index);
1182                 if (ch == '\r' || ch == '\n') {
1183                     return index + 1;
1184                 }
1185                 if (ch != ' ' && ch != '\t' && !Character.isWhitespace(ch)) {
1186                     return fence;
1187                 }
1188             }
1189             return start;
1190         }
1191     }
1192 
1193     static Stream<String> lines(byte[] value, int leading, int trailing) {
1194         if (leading == 0 && trailing == 0) {
1195             return StreamSupport.stream(LinesSpliterator.spliterator(value), false);
1196         } else {
1197             return StreamSupport.stream(LinesSpliterator.spliterator(value, leading, trailing), false);
1198         }
1199     }
1200 
1201     private static void putChars(byte[] val, int index, char[] str, int off, int end) {
1202         while (off < end) {
1203             putChar(val, index++, str[off++]);
1204         }
1205     }
1206 
1207     public static String newString(byte[] val, int index, int len) {
1208         if (String.COMPACT_STRINGS) {
1209             byte[] buf = compress(val, index, len);
1210             if (buf != null) {
1211                 return new String(buf, LATIN1);
1212             }
1213         }
1214         int last = index + len;
1215         return new String(Arrays.copyOfRange(val, index << 1, last << 1), UTF16);
1216     }
1217 
1218     public static void fillNull(byte[] val, int index, int end) {

1109                 int start = index;
1110                 index = mid;
1111                 return new LinesSpliterator(value, start, mid - start);
1112             }
1113             return null;
1114         }
1115 
1116         @Override
1117         public long estimateSize() {
1118             return fence - index + 1;
1119         }
1120 
1121         @Override
1122         public int characteristics() {
1123             return Spliterator.ORDERED | Spliterator.IMMUTABLE | Spliterator.NONNULL;
1124         }
1125 
1126         static LinesSpliterator spliterator(byte[] value) {
1127             return new LinesSpliterator(value, 0, value.length >>> 1);
1128         }









































1129     }
1130 
1131     static Stream<String> lines(byte[] value) {






















1132         return StreamSupport.stream(LinesSpliterator.spliterator(value), false);



1133     }
1134 
1135     private static void putChars(byte[] val, int index, char[] str, int off, int end) {
1136         while (off < end) {
1137             putChar(val, index++, str[off++]);
1138         }
1139     }
1140 
1141     public static String newString(byte[] val, int index, int len) {
1142         if (String.COMPACT_STRINGS) {
1143             byte[] buf = compress(val, index, len);
1144             if (buf != null) {
1145                 return new String(buf, LATIN1);
1146             }
1147         }
1148         int last = index + len;
1149         return new String(Arrays.copyOfRange(val, index << 1, last << 1), UTF16);
1150     }
1151 
1152     public static void fillNull(byte[] val, int index, int end) {