281var paramsEndPosition = span.Slice(2).IndexOfAnyInRange('@', '~');

33content = content.Slice(1);

417var fieldName = remainder.Slice(dotIndex + 1).ToString();

281var paramsEndPosition = span.Slice(2).IndexOfAnyInRange('@', '~');

33content = content.Slice(1);

33content = content.Slice(1);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

395if (!name.Slice(name.Length - type.Name.Length).Equals(type.Name.AsSpan(), StringComparison.Ordinal))

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

22var currentName = dot < 0 ? roSpan : roSpan.Slice(dot + 1);

355name = name.Slice(_declaringType._nestedNameLength + 1); 360name = name.Slice(idx + 1);

86_inputString = _inputString.Slice(fullTypeNameLength); 255_inputString = _inputString.Slice(candidate.Length);

205ReadOnlySpan<char> trimmed = span.Slice(1).TrimStart(); 211span = trimmed.Slice(1).TrimStart(); 232int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType); 336span = span.Slice(1).TrimStart();

3437source = source.Slice(charsUsed);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

100ReadOnlySpan<char> slice = inputSpan.Slice(pos); 116slice = slice.Slice(iteration);

100ReadOnlySpan<char> slice = inputSpan.Slice(pos); 116slice = slice.Slice(iteration);

133value = value.Slice(lastSlashIndex + 1);

147get => this.CurrentSpan.Slice(this.CurrentSpanIndex);

151ReadOnlySpan<byte> actualCiphertext = protectedData.Slice(sizeof(uint) + sizeof(Guid)); // chop off magic header + key id

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

116source = source.Slice(charsUsed);

195buffer = buffer.Slice(charsUsed);

202if (!int.TryParse(networkSpan.Slice(forwardSlashIndex + 1), out prefixLength))

88var cultureName = potentialCultureName.Slice(_culturePrefix.Length); 89var uiCultureName = potentialUICultureName.Slice(_uiCulturePrefix.Length);

293url = url.Slice(start);

193remainingName = remainingName.Slice(indexOfInvalidCharacter + 1);

195buffer = buffer.Slice(charsUsed);

203value = value.Slice(start: toWrite);

107buffer = buffer.Slice(toWrite);

85value = value.Slice(bytes); 101value = value.Slice(bytes);

133value = value.Slice(lastSlashIndex + 1);

101port = host.Slice(pivot + 1); 113MemoryExtensions.EndsWith(requestHost, host.Slice(WildcardHost.Length), StringComparison.OrdinalIgnoreCase))

100ReadOnlySpan<char> slice = inputSpan.Slice(pos); 116slice = slice.Slice(iteration);

545if (transferEncoding.AsSpan().Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase))

131var portValueString = portString.Slice(1); // Trim the leading ":"

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

938if (transferEncoding.AsSpan().Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase))

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

378value = value.Slice(offset); 391byteValue = byteValue.Slice(sizeof(ulong)); 396byteValue = byteValue.Slice(sizeof(ulong)); 411byteValue = byteValue.Slice(sizeof(ulong)); 437value = value.Slice(offset); 474value = value.Slice(offset); 565values = values.Slice(offset); 574byteValue = byteValue.Slice(sizeof(ulong)); 598values = values.Slice(offset); 631values = values.Slice(offset);

447var index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark, BytePercentage); 455index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark); 503var remaining = requestLine.Slice(offset);

628dataToFrame = dataToFrame.Slice(currentSize);

100ReadOnlySpan<char> slice = inputSpan.Slice(pos); 116slice = slice.Slice(iteration);

19buffer = buffer.Slice(aLength);

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

143int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 164ReadOnlySpan<char> slice = inputSpan.Slice(pos); 181slice = slice.Slice(iteration); 195slice = inputSpan.Slice(pos); 212slice = slice.Slice(iteration1); 315ReadOnlySpan<char> slice = inputSpan.Slice(pos); 336slice = slice.Slice(iteration); 348int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 359slice = slice.Slice(iteration1); 459ReadOnlySpan<char> slice = inputSpan.Slice(pos); 471slice = inputSpan.Slice(pos); 489slice = inputSpan.Slice(pos); 494slice = inputSpan.Slice(pos); 526slice = inputSpan.Slice(pos); 538slice = inputSpan.Slice(pos);

19buffer = buffer.Slice(aLength);

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

67frame.StreamId = (int)Bitshifter.ReadUInt31BigEndian(header.Slice(StreamIdOffset)); 124extendedHeaders = extendedHeaders.Slice(1); 134frame.HeadersPriorityWeight = extendedHeaders.Slice(4)[0]; 154frame.GoAwayErrorCode = (Http2ErrorCode)BinaryPrimitives.ReadUInt32BigEndian(extendedHeaders.Slice(4)); 166frame.PriorityWeight = extendedHeaders.Slice(4)[0]; 236data = data.Slice(SettingSize); 244var value = BinaryPrimitives.ReadUInt32BigEndian(payload.Slice(2));

195buffer = buffer.Slice(charsUsed);

195buffer = buffer.Slice(charsUsed);

195buffer = buffer.Slice(charsUsed);

175span = span.Slice(keyValuePair.Length + andDelimiter.Length); 219value = keyValuePair.Slice(equals + equalsDelimiter.Length);

156value = value.Slice(written);

89anchorText = uriToBeAppended.Slice(anchorIndex);

78if (TryGetMatchingKnownBuildCommand(commandSpan.Slice(start), out var knownBuildCommand))

793int foundIndex = expression.Slice(index).IndexOf(quoteChar); 4505remainder = expressionFunctionAsSpan.Slice(argumentsEndIndex + 1).Trim(); 4525remainder = expressionFunctionAsSpan.Slice(nextMethodIndex).Trim();

164input = input.Slice(totalLength);

933projectDisplayPathSpan = outputPathSpan.Slice(workingDirectorySpan.Length + 1); 948projectDisplayPathSpan = Path.Combine(relativePathFromWorkingDirToSourceRoot.ToString(), outputPathSpan.Slice(sourceRootSpan.Length).ToString()).AsSpan();

154data = data.Slice(nullIndex + 1); 744data = data.Slice(sizeof(int)); 753data = data.Slice(execPathEnd + 1); 758data = data.Slice(1);

136span = span.Slice(1); 160span = span.Slice(dotIndex + 1);

833int directoryLength = value.Slice(1).IndexOf('/') + 1;

154data = data.Slice(nullIndex + 1); 744data = data.Slice(sizeof(int)); 753data = data.Slice(execPathEnd + 1); 758data = data.Slice(1);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

26_span = _span.Slice(sizeof(uint)); 33_span = _span.Slice(sizeof(byte)); 40_span = _span.Slice(sizeof(ushort)); 47_span = _span.Slice(byteCount); 54_span = _span.Slice(sizeof(int));

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

227singleNamespaceBuilder.Add(@namespace.Slice(currentIndex).ToString());

40var methodName = spanName.Slice(lastDotIndex + 1);

209span = span.Slice(end);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

26_span = _span.Slice(sizeof(uint)); 33_span = _span.Slice(sizeof(byte)); 40_span = _span.Slice(sizeof(ushort)); 47_span = _span.Slice(byteCount); 54_span = _span.Slice(sizeof(int));

113input = input.Slice(slice.Length); 142var low = BinaryPrimitives.ReadUInt64BigEndian(span.Slice(8));

139arithmetic.HandleOperation(operation, leftSpan.Slice(availableInRetSpan), rightSpan.Slice(availableInRetSpan), nextRetSpan); 181arithmetic.HandleOperation(operation, leftSpan.Slice(availableInRetSpan), right, nextRetSpan);

79Type = (RpmHeaderEntryType)BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(4)), 80Offset = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(8)), 81Count = BinaryPrimitives.ReadInt32BigEndian(bytes.Slice(12))

50return value.Slice(wordStart.Value);

41input = input.Slice(1);

29trimmed = trimmed.Slice(markerLength);

200entropy = BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(2)); 201long creationTime = BinaryPrimitives.ReadInt64LittleEndian(bytes.Slice(4)); 202bytes = bytes.Slice(12); // the end of the fixed part 294|| BinaryPrimitives.ReadUInt16LittleEndian(bytes.Slice(payloadLength)) != UInt16SentinelPrefixPair) 367buffer = buffer.Slice(length); 394buffer = buffer.Slice(index); 410buffer = buffer.Slice(index);

104taxonomyValue = valueSpan.Slice(index + 1).ToString();

54SkipAheadOnDelimiter(xSpan.Slice(xDelimiterIndex + 1)); 56SkipAheadOnDelimiter(ySpan.Slice(yDelimiterIndex + 1)); 65a = a.Slice(1);

110ReadOnlySpan<char> overlapContent = chunk.Content.AsSpan().Slice(index);

176remainingContent = remainingContent.Slice(index);

146result.Content = Convert.FromBase64String(url.Slice(commaIndex + 1).ToString());

146result.Content = Convert.FromBase64String(url.Slice(commaIndex + 1).ToString());

153stat = stat.Slice(next); 345ReadOnlySpan<char> second = group.Slice(rangeIndex + 1); 361stats = stats.Slice(groupIndex + 1);

199stat = stat.Slice(next); 492ReadOnlySpan<char> second = group.Slice(rangeIndex + 1); 508stats = stats.Slice(groupIndex + 1); 579ReadOnlySpan<char> usageSlice = content.Slice(usageIndex + UsageUsec.Length); 584Throw.InvalidOperationException($"Could not get usage_usec from '{cpuUsageFile}'. Expected positive number, but got '{new string(content.Slice(usageIndex))}'."); 594ReadOnlySpan<char> periodsSlice = content.Slice(periodsIndex + NrPeriods.Length); 599Throw.InvalidOperationException($"Could not get nr_periods from '{cpuUsageFile}'. Expected positive number, but got '{new string(content.Slice(periodsIndex))}'."); 724ReadOnlySpan<char> periodSlice = content.Slice(3); 739ReadOnlySpan<char> periodSlice = content.Slice(2); 764ReadOnlySpan<char> periodSlice = content.Slice(index + quotaString.Length);

110routeSpan = routeSpan.Slice(1); 376requestRouteAsSpan = requestRouteAsSpan.Slice(1);

174int amp = querySpan.Slice(start).IndexOf('&');

745=> ContainsSpecialSymbol(variableOrTemplateName) ? variableOrTemplateName.Slice(1) : variableOrTemplateName;

29QueryFlags = (QueryFlags)BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(2)), 30QueryCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(4)), 31AnswerCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(6)), 32AuthorityCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(8)), 33AdditionalRecordCount = BinaryPrimitives.ReadUInt16BigEndian(buffer.Slice(10)) 277!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(2), out weight) || 278!BinaryPrimitives.TryReadUInt16BigEndian(buffer.Span.Slice(4), out port) || 298!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2), out serial) || 299!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 4), out refresh) || 300!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 8), out retry) || 301!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 12), out expire) || 302!BinaryPrimitives.TryReadUInt32BigEndian(buffer.Span.Slice(w1 + w2 + 16), out minimum))

83length = httpPathAsSpan.Slice(startIndex).IndexOf(routeSegments.Segments[i + 1].Content[0]); 87length = httpPathAsSpan.Slice(startIndex).IndexOf(ForwardSlash); 92length = httpPathAsSpan.Slice(startIndex).Length;

72var length = httpPathAsSpan.Slice(startIndex).IndexOf(ForwardSlash); 76length = httpPathAsSpan.Slice(startIndex).Length;

42 query = query.Slice(delimeterIndex + 1); 60 var span = segment.Slice(equalIndex + 1);

351 colorAsHex = colorAsHex.Slice(1); 401 colorAsHex = colorAsHex.Slice(1); 936 value = value.Slice(index + 1); 942 value = value.Slice(index + 1); 948 quad3 = value.Slice(index + 1); 978 value = value.Slice(index + 1); 984 triplet2 = value.Slice(index + 1);

21ReadOnlySpan<char> valuesToParse = trimmedLine.Slice(start: firstSeparatorIndex + 1);

1341if (span.Length == 1 || !TryParseCore(span.Slice(1), out val) || (val > ((ulong)max + 1)))

263return CpuMathUtils.DotProductDense(aValues.Slice(offset), bValues, b.Length); 264return CpuMathUtils.DotProductSparse(aValues.Slice(offset), bValues, b.GetIndices(), bValues.Length);

241var regLoss = VectorUtils.NormSquared(currentWeightsValues.Slice(1)) * L2Weight;

327var regLoss = VectorUtils.NormSquared(CurrentWeights.GetValues().Slice(BiasCount)) * L2Weight;

865span = span.Slice(ContinuingSubwordPrefix.Length); 951sSpan = sSpan.Slice(ContinuingSubwordPrefix!.Length); 1041span = span.Slice(ContinuingSubwordPrefix.Length);

1298bytesIndex += Helpers.GetUtf8Bytes(removePrefixSpace ? specialToken.AsSpan().Slice(1) : specialToken.AsSpan(), bytes.AsSpan().Slice(bytesIndex)); 1449specialTokenSpan = specialTokenSpan.Slice(1);

731tokenSpan = tokenSpan.Slice(delta);

133EncodeInternal(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, tokens); 236int bytesWritten = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 395idsCount += EncodeToIds(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, accumulatedIds, out charsWritten, maxTokens - idsCount); 536int bytesWritten = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 671idsCount += CountTokens(text.Slice(currentOffset), addBeginOfSentence: false, addEndOfSentence: false, out charsWritten, maxTokens - idsCount); 799int encodedCount = Helpers.GetUtf8Bytes(text.Slice(i), utf8Bytes); 921splitText = text.Slice(current.Offset + current.Length);

248EncodeToTokensInternal(text.Slice(currentOffset), considerNormalization, ref progressOffset, tokens, buffer, ref normalizedString, ref normalizedStringIndex); 428int codepointLength = Helpers.EncodeNextUtf8(normalizationSpan.Slice(offsetStart), destination); 690EncodeToIdsInternal(text.Slice(currentOffset), considerNormalization, ids, buffer, ref normalizedString, ref normalizedStringIndex, ref charsConsumed, maxTokenCount); 694StoreNormalizedText(text.Slice(currentOffset), considerNormalization, buffer, ref normalizedString, ref normalizedStringIndex); 1060CountTokensInternal(text.Slice(currentOffset), considerNormalization, ref tokenCount, buffer, ref normalizedString, ref normalizedStringIndex, ref charsConsumed, maxTokenCount); 1064StoreNormalizedText(text.Slice(currentOffset), considerNormalization, buffer, ref normalizedString, ref normalizedStringIndex); 1297GetIndexByTokenCountFromEndInternal(text.Slice(current.Offset + current.Length), considerNormalization, ref tokenCount, buffer, ref normalizedString, ref normalizedStringCountFromEnd, ref charConsumedFromEnd, maxTokenCount);

936tokenBytes.Span.Slice(bytesConsumed).CopyTo(utf8Bytes);

696sb.Append(token.AsSpan().Slice(ContinuingSubwordPrefix.Length)); 759token.AsSpan().Slice(ContinuingSubwordPrefix.Length).CopyTo(buffer);

364input = input.Slice(p); 394sp = sp.Slice(1); 429input = input.Slice(p); 510blob = blob.Slice(sizeof(uint)); 532normalized = blob.Slice((int)trieBlobSize).ToArray();

297ReadOnlySpan<char> slice = inputSpan.Slice(pos); 328slice = inputSpan.Slice(pos); 333slice = inputSpan.Slice(pos); 349slice = inputSpan.Slice(pos); 354slice = inputSpan.Slice(pos); 360!slice.Slice(1).StartsWith("ve", StringComparison.OrdinalIgnoreCase)) // Match the string "ve" (ordinal case-insensitive) 366slice = inputSpan.Slice(pos); 371slice = inputSpan.Slice(pos); 377!slice.Slice(1).StartsWith("re", StringComparison.OrdinalIgnoreCase)) // Match the string "re" (ordinal case-insensitive) 383slice = inputSpan.Slice(pos); 393slice = inputSpan.Slice(pos); 402slice = slice.Slice(1); 420slice = slice.Slice(iteration); 428slice = inputSpan.Slice(pos); 446slice = slice.Slice(iteration1); 454slice = inputSpan.Slice(pos); 463slice = slice.Slice(1); 481slice = slice.Slice(iteration2); 493slice = slice.Slice(iteration3); 501slice = inputSpan.Slice(pos); 519slice = slice.Slice(iteration4); 533slice = inputSpan.Slice(pos); 548slice = slice.Slice(iteration5); 565slice = inputSpan.Slice(pos); 577slice = inputSpan.Slice(pos); 582slice = inputSpan.Slice(pos); 602slice = slice.Slice(iteration6); 618slice = inputSpan.Slice(pos); 638slice = inputSpan.Slice(pos); 645slice = inputSpan.Slice(pos); 657slice = inputSpan.Slice(pos); 745ReadOnlySpan<char> slice = inputSpan.Slice(pos); 774slice = inputSpan.Slice(pos); 785slice = inputSpan.Slice(pos); 796slice = inputSpan.Slice(pos); 807slice = inputSpan.Slice(pos); 819slice = inputSpan.Slice(pos); 828slice = slice.Slice(1); 846slice = slice.Slice(iteration); 854slice = inputSpan.Slice(pos); 863slice = slice.Slice(1); 881slice = slice.Slice(iteration1); 889slice = inputSpan.Slice(pos); 898slice = slice.Slice(1); 916slice = slice.Slice(iteration2); 924slice = inputSpan.Slice(pos); 942slice = slice.Slice(iteration3); 956slice = inputSpan.Slice(pos); 976slice = slice.Slice(iteration4); 992slice = inputSpan.Slice(pos); 1012slice = inputSpan.Slice(pos); 1019slice = inputSpan.Slice(pos); 1031slice = inputSpan.Slice(pos); 1131ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1149slice = slice.Slice(1); 1165slice = inputSpan.Slice(pos); 1180slice = slice.Slice(iteration); 1195slice = inputSpan.Slice(pos); 1215slice = slice.Slice(iteration1); 1231slice = inputSpan.Slice(pos); 1265slice = inputSpan.Slice(pos); 1270slice = inputSpan.Slice(pos); 1276!slice.Slice(1).StartsWith("re", StringComparison.OrdinalIgnoreCase)) // Match the string "re" (ordinal case-insensitive) 1282slice = inputSpan.Slice(pos); 1287slice = inputSpan.Slice(pos); 1293!slice.Slice(1).StartsWith("ve", StringComparison.OrdinalIgnoreCase)) // Match the string "ve" (ordinal case-insensitive) 1299slice = inputSpan.Slice(pos); 1304slice = inputSpan.Slice(pos); 1316slice = inputSpan.Slice(pos); 1321slice = inputSpan.Slice(pos); 1337slice = inputSpan.Slice(pos); 1342slice = inputSpan.Slice(pos); 1354slice = inputSpan.Slice(pos); 1376slice = inputSpan.Slice(pos); 1385slice = inputSpan.Slice(pos); 1396slice = slice.Slice(1); 1412slice = inputSpan.Slice(pos); 1432slice = slice.Slice(iteration2); 1448slice = inputSpan.Slice(pos); 1463slice = slice.Slice(iteration3); 1478slice = inputSpan.Slice(pos); 1512slice = inputSpan.Slice(pos); 1517slice = inputSpan.Slice(pos); 1523!slice.Slice(1).StartsWith("re", StringComparison.OrdinalIgnoreCase)) // Match the string "re" (ordinal case-insensitive) 1529slice = inputSpan.Slice(pos); 1534slice = inputSpan.Slice(pos); 1540!slice.Slice(1).StartsWith("ve", StringComparison.OrdinalIgnoreCase)) // Match the string "ve" (ordinal case-insensitive) 1546slice = inputSpan.Slice(pos); 1551slice = inputSpan.Slice(pos); 1563slice = inputSpan.Slice(pos); 1568slice = inputSpan.Slice(pos); 1584slice = inputSpan.Slice(pos); 1589slice = inputSpan.Slice(pos); 1601slice = inputSpan.Slice(pos); 1623slice = inputSpan.Slice(pos); 1632slice = inputSpan.Slice(pos); 1650slice = slice.Slice(iteration4); 1658slice = inputSpan.Slice(pos); 1667slice = slice.Slice(1); 1687slice = slice.Slice(iteration5); 1703slice = inputSpan.Slice(pos); 1716slice = slice.Slice(iteration6); 1724slice = inputSpan.Slice(pos); 1739slice = slice.Slice(iteration7); 1756slice = inputSpan.Slice(pos); 1774slice = slice.Slice(iteration8); 1782slice = inputSpan.Slice(pos); 1802slice = slice.Slice(iteration9); 1818slice = inputSpan.Slice(pos); 1838slice = inputSpan.Slice(pos); 1845slice = inputSpan.Slice(pos); 1863slice = slice.Slice(iteration10); 1938int i = inputSpan.Slice(pos).IndexOfNonAsciiOrAny_A2156A68B3FF2CEFCBABF7078C1AEC356AC590A34A9D31C18E0C21F77ECF6097(); 1958ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1979slice = slice.Slice(iteration); 1987slice = inputSpan.Slice(pos); 1999slice = inputSpan.Slice(pos); 2082ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2103slice = slice.Slice(iteration); 2111slice = inputSpan.Slice(pos); 2129slice = slice.Slice(iteration1); 2201int i = inputSpan.Slice(pos).IndexOfAnyExceptWhiteSpace(); 2221ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2236slice = slice.Slice(iteration);

61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

51=> int.TryParse(s.AsSpan().Slice(offset), NumberStyles.None, CultureInfo.InvariantCulture, out result); 83Rune.DecodeFromUtf16(text.Slice(textIndex), out Rune rune, out int charsConsumed);

115index = original.Slice(start).IndexOf('"');

61utf8Bytes = utf8Bytes.Slice(Math.Min(bytesLength, utf8Bytes.Length));

51=> int.TryParse(s.AsSpan().Slice(offset), NumberStyles.None, CultureInfo.InvariantCulture, out result); 83Rune.DecodeFromUtf16(text.Slice(textIndex), out Rune rune, out int charsConsumed);

631remaining = remaining.Slice(length); 645Rune.DecodeFromUtf16(remaining.Slice(i), out Rune rune, out var runeLength); 650remaining = remaining.Slice(length);

61nameSlice = nameSlice.Slice(escapedComma + 2); 107int tokenEnding = assemblyName.Slice(versionIndex + 1).IndexOf(',') + 1; 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 117int tokenEnding = assemblyName.Slice(tokenIndex + 1).IndexOf(',') + 1; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding;

794contentRangeSpan = contentRangeSpan.Slice(index + 1);

113spanSource = spanSource.Slice(periodPos + 1);

735extensions.Add(exts[ext].Slice(i + 1).ToString());

129contentSpan = contentSpan.Slice(i);

12238name = name.Slice(24); // 24 == length of "s.w.c."

440attrValueSpan = attrValueSpan.Slice(_contextColor.Length).Trim();

430glyphIndexString = valueSpec.Slice(secondBracket + 1);

3560units = s.Slice(n + 1);

360value = value.Slice(2);

1878zoomString = zoomString.Slice(1);

1852ReadOnlySpan<char> extension = Path.GetExtension(path).Slice(1);

296var argValue = line.AsSpan().Slice(index + 1).ToString();

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

162data = data.Slice(i);

368fieldValue = line.Slice(colonPos + 1); 371fieldValue = fieldValue.Slice(1);

276Node right = NodeTreeFromList(items.Slice(leftCount + 1));

72ReadOnlySpan<char> extension = potentialPhoneNumber.Slice( 84ReadOnlySpan<char> extension = potentialPhoneNumber.Slice( 96ReadOnlySpan<char> extension = potentialPhoneNumber.Slice(

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

97return Convert.ToInt32(text.Slice(1).ToString(), 16); 101return Convert.ToInt32(text.Slice(2).ToString(), 16);

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

286ReadOnlySpan<char> slice = inputSpan.Slice(pos); 308slice = slice.Slice(iteration); 329slice = inputSpan.Slice(pos); 338slice = inputSpan.Slice(pos); 359slice = inputSpan.Slice(pos); 392slice = inputSpan.Slice(pos); 397slice = inputSpan.Slice(pos); 418slice = slice.Slice(iteration1); 440slice = inputSpan.Slice(pos); 456slice = inputSpan.Slice(pos); 461slice = inputSpan.Slice(pos); 480slice = slice.Slice(iteration2); 493slice = inputSpan.Slice(pos); 498slice = inputSpan.Slice(pos); 513slice = inputSpan.Slice(pos); 553slice = inputSpan.Slice(pos); 615slice = slice.Slice(iteration3); 628slice = inputSpan.Slice(pos); 649slice = inputSpan.Slice(pos); 662slice = slice.Slice(iteration4); 683slice = inputSpan.Slice(pos); 710slice = inputSpan.Slice(pos); 735slice = inputSpan.Slice(pos); 740slice = inputSpan.Slice(pos); 755slice = inputSpan.Slice(pos); 791slice = inputSpan.Slice(pos); 834slice = inputSpan.Slice(pos); 839slice = inputSpan.Slice(pos); 854slice = inputSpan.Slice(pos); 879slice = inputSpan.Slice(pos); 884slice = inputSpan.Slice(pos); 899slice = inputSpan.Slice(pos); 935slice = inputSpan.Slice(pos); 978slice = inputSpan.Slice(pos); 983slice = inputSpan.Slice(pos); 991slice = inputSpan.Slice(pos); 1012slice = inputSpan.Slice(pos); 1041slice = inputSpan.Slice(pos); 1046slice = inputSpan.Slice(pos); 1067slice = slice.Slice(iteration5); 1089slice = inputSpan.Slice(pos); 1105slice = inputSpan.Slice(pos); 1141slice = inputSpan.Slice(pos); 1177slice = inputSpan.Slice(pos); 1199slice = inputSpan.Slice(pos); 1251slice = slice.Slice(iteration6); 1272slice = inputSpan.Slice(pos); 1295slice = inputSpan.Slice(pos); 1300slice = inputSpan.Slice(pos); 1316slice = slice.Slice(iteration7); 1337slice = inputSpan.Slice(pos); 1388slice = inputSpan.Slice(pos); 1417slice = slice.Slice(iteration8); 1436slice = inputSpan.Slice(pos); 1450slice = slice.Slice(iteration9); 1541ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1563slice = slice.Slice(iteration); 1584slice = inputSpan.Slice(pos); 1613slice = inputSpan.Slice(pos); 1646slice = inputSpan.Slice(pos); 1651slice = inputSpan.Slice(pos); 1672slice = slice.Slice(iteration1); 1694slice = inputSpan.Slice(pos); 1710slice = inputSpan.Slice(pos); 1746slice = inputSpan.Slice(pos); 1808slice = slice.Slice(iteration2); 1821slice = inputSpan.Slice(pos); 1830slice = slice.Slice(iteration3); 1851slice = inputSpan.Slice(pos); 1878slice = inputSpan.Slice(pos); 1903slice = inputSpan.Slice(pos); 1908slice = inputSpan.Slice(pos); 1923slice = inputSpan.Slice(pos); 1959slice = inputSpan.Slice(pos); 2002slice = inputSpan.Slice(pos); 2007slice = inputSpan.Slice(pos); 2035slice = inputSpan.Slice(pos); 2064slice = inputSpan.Slice(pos); 2069slice = inputSpan.Slice(pos); 2090slice = slice.Slice(iteration4); 2112slice = inputSpan.Slice(pos); 2128slice = inputSpan.Slice(pos); 2164slice = inputSpan.Slice(pos); 2245slice = slice.Slice(iteration5); 2266slice = inputSpan.Slice(pos); 2289slice = inputSpan.Slice(pos); 2294slice = inputSpan.Slice(pos); 2310slice = slice.Slice(iteration6); 2331slice = inputSpan.Slice(pos); 2382slice = inputSpan.Slice(pos); 2411slice = slice.Slice(iteration7); 2430slice = inputSpan.Slice(pos); 2444slice = slice.Slice(iteration8); 2539ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2549slice = inputSpan.Slice(pos); 2570slice = inputSpan.Slice(pos); 2588slice = slice.Slice(iteration); 2607slice = inputSpan.Slice(pos); 2614slice = inputSpan.Slice(pos); 2636slice = inputSpan.Slice(pos); 2720ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2736slice = slice.Slice(iteration); 2827ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2844slice = inputSpan.Slice(pos); 2868slice = inputSpan.Slice(pos); 2873slice = inputSpan.Slice(pos); 2887slice = inputSpan.Slice(pos); 2922slice = inputSpan.Slice(pos);

231ReadOnlySpan<char> suffixPart = entry.Slice(eventNameIndex + 1).Trim(); 237suffixPart = suffixPart.Slice(samplingResultIndex + 1).Trim(); 331activityName = activitySourceName.Slice(plusSignIndex + 1).Trim().ToString();

109ReadOnlySpan<char> valueSpan = currentEntry.Slice(keyValueSeparator + 1); 117baggageSpan = entrySeparator >= 0 ? baggageSpan.Slice(entrySeparator + 1) : ReadOnlySpan<char>.Empty; 166if (IsInvalidTraceStateKey(Trim(entry.Slice(0, equalIndex))) || IsInvalidTraceStateValue(TrimSpaceOnly(entry.Slice(equalIndex + 1)))) 282if (!TryDecodeEscapedByte(valueSpan.Slice(i), out byte b0)) 297if (i + 5 >= valueSpan.Length || valueSpan[i + 3] != Percent || !TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || (b1 & 0xC0) != 0x80) 316!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 317!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 338!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 339!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 340!TryDecodeEscapedByte(valueSpan.Slice(i + 9), out byte b3) ||

85ReadOnlySpan<char> value = line.Slice(startIndex + 1);

59line = line.Slice(endOfOptionalFields + Separator.Length);

317argRemainder = argRemainder.Slice(argEnd + 1); 349string argString = Encoding.UTF8.GetString(arg.Slice(nameStart));

97return Convert.ToInt32(text.Slice(1).ToString(), 16); 101return Convert.ToInt32(text.Slice(2).ToString(), 16);

323bytes.Slice(bytes.Length - 1).ToArray(), 334char c = (char)BinaryPrimitives.ReadInt16BigEndian(bytes.Slice(i));

308int tooBig = contentsLength ?? SeekEndOfContents(source.Slice(headerLength), ruleSet); 391value = source.Slice(1); 503cur = cur.Slice(localLen); 525cur = topSpan.Slice(bytesRead); 575cur = tmpSpan.Slice(bytesRead); 905_data = _data.Slice(consumed); 967_data = _data.Slice(consumed); 1015_data = _data.Slice(consumed);

151_data = _data.Slice(bytesConsumed);

74TryReadLength(source.Slice(tagLength), ruleSet, out int? encodedLength, out int lengthLength)) 79source.Slice(headerLength), 153int? encodedLength = ReadLength(source.Slice(tagLength), ruleSet, out int lengthLength); 157source.Slice(headerLength), 185int? encodedLength = ReadLength(source.Slice(tagLength), ruleSet, out int lengthLength); 452int? length = ReadLength(source.Slice(tagBytesRead), ruleSet, out int lengthBytesRead); 602cur = cur.Slice(bytesRead); 611cur = cur.Slice(tlv.Length); 622data = data.Slice(bytesToRead); 663return source.Slice(offset); 1042_data = _data.Slice(encodedValue.Length);

447_data = _data.Slice(consumed); 498_data = _data.Slice(consumed); 552_data = _data.Slice(consumed);

215contents = contents.Slice(1); 239contents = contents.Slice(fracLength); 247contents = contents.Slice(fracLength); 270contents = contents.Slice(1); 470_data = _data.Slice(consumed);

494contents = contents.Slice(1); 784_data = _data.Slice(consumed); 817_data = _data.Slice(consumed); 856_data = _data.Slice(read); 896_data = _data.Slice(read); 935_data = _data.Slice(read); 975_data = _data.Slice(read);

674_data = _data.Slice(consumed); 729_data = _data.Slice(consumed); 761_data = _data.Slice(consumed);

125_data = _data.Slice(consumed);

362cur = cur.Slice(localLen); 390cur = topSpan.Slice(bytesRead); 440cur = topSpan.Slice(bytesRead); 503contents = source.Slice(headerLength); 735_data = _data.Slice(bytesConsumed); 773_data = _data.Slice(consumed); 821_data = _data.Slice(consumed);

303contents = contents.Slice(bytesRead); 332contents = contents.Slice(bytesRead); 407_data = _data.Slice(consumed);

89int len = SeekEndOfContents(source.Slice(headerLength), ruleSet); 195_data = _data.Slice(bytesConsumed);

92int actualLength = SeekEndOfContents(source.Slice(headerLength), ruleSet); 112remaining = remaining.Slice(consumed); 319_data = _data.Slice(bytesConsumed);

784_data = _data.Slice(consumed); 842_data = _data.Slice(consumed); 910_data = _data.Slice(consumed); 964_data = _data.Slice(consumed);

190contents = contents.Slice(1); 366_data = _data.Slice(consumed); 406_data = _data.Slice(consumed);

176remainingData = remainingData.Slice(MaxCERContentSize);

154remainingData = remainingData.Slice(MaxCERSegmentSize);

114ReadOnlySpan<char> remaining = oidValue.Slice(2); 173oidValue = oidValue.Slice(Math.Min(oidValue.Length, endIndex + 1));

253private ReadOnlySpan<byte> GetRemainingBytes() => _data.Span.Slice(_offset);

181result = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(1)); 193result = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(1)); 205result = BinaryPrimitives.ReadUInt64BigEndian(data.Slice(1));

32result = HalfHelpers.HalfToFloat(CborHelpers.ReadHalfBigEndian(buffer.Slice(1))); 39result = CborHelpers.ReadSingleBigEndian(buffer.Slice(1)); 73result = HalfHelpers.HalfToDouble(CborHelpers.ReadHalfBigEndian(buffer.Slice(1))); 80result = CborHelpers.ReadSingleBigEndian(buffer.Slice(1)); 87result = CborHelpers.ReadDoubleBigEndian(buffer.Slice(1));

32result = BinaryPrimitives.ReadHalfBigEndian(buffer.Slice(1));

453CborInitialByte nextInitialByte = ReadNextInitialByte(data.Slice(i), type); 457int chunkLength = DecodeDefiniteLength(nextInitialByte, data.Slice(i), out int bytesRead); 462nextInitialByte = ReadNextInitialByte(data.Slice(i), type);

144encodedValue = encodedValue.Slice(1);

20path = path.Slice(nonSlash);

790line = line.Slice(spacePos + 1); 800ReadOnlySpan<byte> valueSlice = line.Slice(equalPos + 1); 807buffer = buffer.Slice(newlinePos + 1);

611name = pathNameBytes.Slice(lastIdx + 1); 625name = pathNameBytes.Slice(lastIdx + 1);

235return T.ReadBigEndian(buffer.Slice(1), isUnsigned: true);

616bool result = ZipCentralDirectoryFileHeader.TryReadBlock(sizedFileBuffer.Slice(currPosition), _archiveStream,

196while (ZipGenericExtraField.TryReadBlock(extraFieldData.Slice(totalBytesConsumed), out int currBytesConsumed, out ZipGenericExtraField currentExtraField)) 263data = data.Slice(FieldLengths.UncompressedSize); 267data = data.Slice(FieldLengths.UncompressedSize); 278data = data.Slice(FieldLengths.CompressedSize); 282data = data.Slice(FieldLengths.CompressedSize); 293data = data.Slice(FieldLengths.LocalHeaderOffset); 297data = data.Slice(FieldLengths.LocalHeaderOffset);

143buffer = buffer.Slice(bytesConsumed);

96source = source.Slice(source.Length - (int)availableInput);

178source = source.Slice(source.Length - (int)availableInput);

97buffer = buffer.Slice(bytesConsumed);

20path = path.Slice(nonSlash);

59line = line.Slice(endOfOptionalFields + Separator.Length);

233source = source.Slice(k);

142value = UpdateScalar(value, source.Slice(consumed)); 176value = UpdateScalar(value, source.Slice(consumed));

149source = source.Slice(longLength); 180source = source.Slice(intLength); 223source = source.Slice(ulongData.Length * sizeof(ulong)); 236ReadOnlySpan<byte> remainingBytes = source.Slice(uintData.Length * sizeof(uint)); 270ReadOnlySpan<byte> remainingBytes = source.Slice(offset);

142value = UpdateScalar(value, source.Slice(consumed)); 176value = UpdateScalar(value, source.Slice(consumed));

102source = source.Slice(remain); 116source = source.Slice(StripeSize); 260source = source.Slice(StripeSize);

43_acc2 = ApplyRound(_acc2, source.Slice(sizeof(uint))); 44_acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(uint))); 45_acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(uint))); 82remaining = remaining.Slice(sizeof(uint));

102source = source.Slice(remain); 116source = source.Slice(StripeSize); 260source = source.Slice(StripeSize);

54_acc2 = ApplyRound(_acc2, source.Slice(sizeof(ulong))); 55_acc3 = ApplyRound(_acc3, source.Slice(2 * sizeof(ulong))); 56_acc4 = ApplyRound(_acc4, source.Slice(3 * sizeof(ulong))); 118remaining = remaining.Slice(sizeof(ulong)); 130remaining = remaining.Slice(sizeof(uint));

140ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 326source.Slice(sourceIndex).CopyTo(remaining);

288typeAndSubType.Slice(forwardSlashPos + 1).Contains('/')) // more than one slash 294_subType = ValidateToken(typeAndSubType.Slice(forwardSlashPos + 1).ToString()); 319parameterAndValue = parameterAndValue.Slice(1); 339parameterAndValue = parameterAndValue.Slice(parameterStartIndex + parameterValueLength).TrimStart(s_linearWhiteSpaceChars); 358int semicolonIndex = s.Slice(startIndex).IndexOf(';'); 362int lwsIndex = s.Slice(startIndex).IndexOfAny(s_linearWhiteSpaceChars); 383length = s.Slice(startingLength).IndexOf('"');

1106source = source.Slice(writable);

294buffer = buffer.Slice(bytesWritten);

37Vector.Widen(new Vector<int>(span.Slice(i)), out Vector<long> low, out Vector<long> high);

148sourceSlice = sourceSpan.Slice(sourceSlice.Length);

140input = input.Slice(writeSize);

187return span.Slice(startIndex); 651first = first.Slice(startIndex);

79get => CurrentSpan.Slice(CurrentSpanIndex);

837next = next.Slice(currentSpan.Length);

440chars = chars.Slice(charsUsedJustNow); 533bytes = bytes.Slice(bytesUsedJustNow);

114_content.Span.Slice(_position).CopyTo(buffer); 161destination.Write(_content.Span.Slice(_position));

469span = span.Slice(3);

114_content.Span.Slice(_position).CopyTo(buffer); 161destination.Write(_content.Span.Slice(_position));

19buffer = buffer.Slice(aLength);

420source = source.Slice(block.Length);

79escapedChars = escapedChars.Slice(indexOfEscapedSpace + 3); // Skip "%20"

271value = value.Slice(idx + 3); 318if (!TryReadQuotedInt32Value(quoted.Slice(idx + 1), out port)) 373value = value.Slice(idx + 2);

87utf8 = utf8.Slice(length); 105utf8 = utf8.Slice(length);

1012buffer = buffer.Slice(remainingInCurrentBuffer.Length);

432valueSpan = valueSpan.Slice(i + 1);

342ValidateChunkExtension(currentLine.Slice(bytesConsumed));

721frameData = frameData.Slice(1); 739frameData = frameData.Slice(FrameHeader.PriorityInfoLength); 761span = span.Slice(2); 769span = span.Slice(originLength); 851settings = settings.Slice(2); 853settings = settings.Slice(4); 1939int streamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(buffer.Slice(5)) & 0x7FFFFFFF);

1256value = value.Slice(1); 1396source = source.Slice(remaining); 1686if (TryFindEndOfLine(_readBuffer.ActiveReadOnlySpan.Slice(searchOffset), out int offset)) 1740buffer = buffer.Slice(tabOrSpaceIndex + 1);

66span = span.Slice(charactersConsumed); 219proxyString = proxyString.Slice(iter); 228proxyString = proxyString.Slice("http=".Length); 233proxyString = proxyString.Slice("https=".Length); 242proxyString = proxyString.Slice("http://".Length); 250proxyString = proxyString.Slice("https://".Length); 269proxyString = proxyString.Slice(iter);

104_version = Version.Parse(version.Slice("HTTP/".Length));

227written += EncodeBytes(buffer.Slice(written), false, false); 247written += EncodeBytes(buffer.Span.Slice(written), false, false);

33if (_hasSpecialEncodingForCRLF && buffer.Slice(cur).StartsWith("\r\n"u8))

233written += EncodeBytes(buffer.Slice(written)); 250written += EncodeBytes(buffer.Span.Slice(written));

347written += EncodeBytes(buffer.Slice(written)); 364written += EncodeBytes(buffer.Span.Slice(written));

213numbers[i] = BinaryPrimitives.ReadUInt16BigEndian(address.Slice(i * 2)); 725MemoryMarshal.Read<uint>(numbers.Slice(4)), 726MemoryMarshal.Read<uint>(numbers.Slice(8)), 727MemoryMarshal.Read<uint>(numbers.Slice(12)),

97scopeIdSpan = scopeIdSpan.Slice(1);

132ReadOnlySpan<TChar> portSpan = s.Slice(addressLength + 1);

185ReadOnlySpan<char> prefixLengthSpan = s.Slice(separatorIndex + 1); 213ReadOnlySpan<byte> prefixLengthSpan = utf8Text.Slice(separatorIndex + 1);

420source = source.Slice(block.Length);

121buffer = buffer.Slice(bytesWritten); 149buffer = buffer.Slice(bytesWritten);

127MD4Transform(state, input.Slice(i)); 132input.Slice(i).CopyTo(buffer.Slice(index)); 185output[i] = BinaryPrimitives.ReadUInt32LittleEndian(input.Slice(j));

48source = source.Slice(pos); 71source = source.Slice(1);

548info = info.Slice(length + 4); 564info = info.Slice(length + 4); 849_serverSeal.Transform(input.Slice(SignatureLength), output.Slice(0, input.Length - SignatureLength));

524if (!TlsFrameHelper.TryGetFrameHeader(availableData.Slice(chunkSize), ref nextHeader))

281if (!TryParseHelloFrame(frame.Slice(HeaderSize), ref info, options, callback)) 389int helloLength = ReadUInt24BigEndian(sslHandshake.Slice(HelloLengthOffset)); 390ReadOnlySpan<byte> helloData = sslHandshake.Slice(HelloOffset); 542info.RawApplicationProtocols = extensionData.Slice(sizeof(short)).ToArray(); 547extensions = extensions.Slice(extensionLength); 569ReadOnlySpan<byte> serverNameList = serverNameListExtension.Slice(ServerNameListOffset); 602ReadOnlySpan<byte> hostNameStruct = serverName.Slice(HostNameStructOffset); 620ReadOnlySpan<byte> hostName = hostNameStruct.Slice(HostNameOffset); 649extensionData = extensionData.Slice(VersionListNameOffset); 664extensionData = extensionData.Slice(VersionLength); 690ReadOnlySpan<byte> alpnList = extensionData.Slice(AlpnListOffset); 726alpnList = alpnList.Slice(protocolLength + 1); 795return (numberOfBytesToSkip < bytes.Length) ? bytes.Slice(numberOfBytesToSkip) : ReadOnlySpan<byte>.Empty;

211port = hostAndPort.Slice(colonIndex + 1); // Excludes colon 220port = hostAndPort.Slice(colonIndex);

159data = data.Slice(i);

352fieldValue = line.Slice(colonPos + 1); 355fieldValue = fieldValue.Slice(1);

52buffer = buffer.Slice(toCopy);

68ReadOnlySpan<char> lastElement = singleValue.Slice(semiPos + 1);

64payload = payload.Slice(consumed);

1640BitConverter.ToInt32(buffer.Slice(maskOffset)); 1769int firstNonAscii = span.Slice(i).IndexOfAnyExceptInRange((byte)0, (byte)127);

343!int.TryParse(value.Slice(startIndex + 1), NumberStyles.Integer, CultureInfo.InvariantCulture, out int windowBits) ||

2299tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2311tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2336tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2348tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2373tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2385tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1));

65ReadOnlySpan<char> fieldValue = line.Slice(prefix.Length);

85ReadOnlySpan<char> value = line.Slice(startIndex + 1);

59line = line.Slice(endOfOptionalFields + Separator.Length);

441fallbackResult = TryDecodeFromUtf8_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed); 446fallbackResult = TryDecodeFromUtf16_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);

306return !value.Slice(index).ContainsAnyExcept(TChar.CastFrom('\0'));

42source = source.Slice(4);

280source = source.Slice(bytesConsumed); 309source = source.Slice(localConsumed); 325source = source.Slice(localConsumed); 478source = source.Slice(1); 500source = source.Slice(encodedIdx); 583source = source.Slice(1); 605source = source.Slice(encodedIdx);

37base64Text = base64Text.Slice(index + 1); 45base64Text = base64Text.Slice(1);

159int diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex)) ^ infi); 164diff = (BinaryPrimitives.ReadInt32LittleEndian(source.Slice(srcIndex + 4)) ^ nity);

91if (!TryParseUInt64X(text.Slice(20), out ulong i5, out justConsumed) || justConsumed != 12) 132source = source.Slice(1); // skip beginning 157source = source.Slice(9); // justConsumed + 1 for delimiter 180source = source.Slice(5); // justConsumed + 1 for delimiter 203source = source.Slice(5); // justConsumed + 1 for delimiter 226source = source.Slice(5); // justConsumed + 1 for delimiter

261if (!TryParseUInt32D(source.Slice(srcIndex), out uint absoluteExponent, out int bytesConsumedByExponent))

40if (!TryParseUInt32D(source.Slice(srcIndex), out uint days, out int justConsumed)) 55if (!TryParseUInt32D(source.Slice(srcIndex), out uint hours, out justConsumed)) 70if (!TryParseUInt32D(source.Slice(srcIndex), out uint minutes, out justConsumed)) 85if (!TryParseUInt32D(source.Slice(srcIndex), out uint seconds, out justConsumed)) 100if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out uint fraction, out justConsumed))

73if (!TryParseUInt32D(source.Slice(srcIndex), out V1, out int justConsumed)) 192if (!TryParseUInt32D(source.Slice(srcIndex), out value, out int bytesConsumed)) 205if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out value, out int bytesConsumed))

2466source = source.Slice(chunkSize);

643int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4)); 644int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8)); 645int flags = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(12));

34payload = payload.Slice(IntPtr.Size); 39payload = payload.Slice(sizeof(int)); 44payload = payload.Slice(sizeof(uint)); 49payload = payload.Slice(sizeof(long)); 54payload = payload.Slice(sizeof(ulong)); 59payload = payload.Slice(sizeof(byte)); 64payload = payload.Slice(sizeof(sbyte)); 69payload = payload.Slice(sizeof(short)); 74payload = payload.Slice(sizeof(ushort)); 79payload = payload.Slice(sizeof(float)); 84payload = payload.Slice(sizeof(double)); 90payload = payload.Slice(sizeof(int)); 96payload = payload.Slice(sizeOfGuid); 101payload = payload.Slice(sizeof(char)); 127payload = payload.Slice(byteCount);

1070value = value.Slice(endIndex + 1); 2262rawData = rawData.Slice(sizeof(long) - size);

110string value = new string(variable.Slice(i + 1));

196? source.Slice(endIndex) 838text = text.Slice(charsConsumed);

1239if (str.Value.Slice(str.Index + 1).ContainsAnyExcept('\0')) 3410ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3511ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3612ReadOnlySpan<char> span = str.Value.Slice(str.Index); 3679ReadOnlySpan<char> span = str.Value.Slice(str.Index); 5783if (++Index < Length && Value.Slice(Index).StartsWith(str)) 6001Value.Slice(i + 1).CopyTo(result.Slice(1));

429iNextDot = unicode.Slice(iAfterLastDot).IndexOfAny(DotSeparators); 517if (unicode.Slice(iAfterLastDot).StartsWith(c_strAcePrefix, StringComparison.OrdinalIgnoreCase))

60ToLower(src.Slice(i), destination.Slice(i)); 106ToUpper(src.Slice(i), destination.Slice(i));

97spanA = spanA.Slice(bytesConsumedA); 98spanB = spanB.Slice(bytesConsumedB); 407spanA = spanA.Slice(bytesConsumedA); 408spanB = spanB.Slice(bytesConsumedB);

221remaining = remaining.Slice(GetNextTextElementLength(remaining)); // consume this cluster

1492int i = _str.Slice(_pos).IndexOfAnyExceptInRange('0', '9');

696int numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 718numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 740numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 778numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 787numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom('}')); 863guidString = guidString.Slice(1); 868guidString = guidString.Slice(2); 942if (Rune.DecodeFromUtf8(srcUtf8Span.Slice(i), out Rune current, out int bytesConsumed) != Buffers.OperationStatus.Done) 973if (Rune.DecodeFromUtf8(srcUtf8Span.Slice(i), out Rune current, out int bytesConsumed) != Buffers.OperationStatus.Done)

458chars = chars.Slice(charsConsumed);

955buffer = buffer.Slice(bytesWritten);

38ReadOnlySpan<char> relativePath = Directory.Slice(RootDirectory.Length); 40relativePath = relativePath.Slice(1);

157ReadOnlySpan<char> expressionEnd = expression.Slice(1); 281name.Slice(nameOffset).Contains('.'); 428span = span.Slice(i + 1);

1590contents = contents.Slice(toEncode.Length);

247return path.Slice(i < root ? root : i + 1);

149buffer = buffer.Slice(bytesWritten);

509source = source.Slice(numBytes);

2386if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer)) 2392span = span.Slice(pos + 1); 2598if (span.Slice(pos + 1).StartsWith(value.Slice(1), comparer)) 3662SequenceEqual(span.Slice(span.Length - value.Length), value, comparer); 5575span = span.Slice(pos + value.Length); 5605span = span.Slice(pos + value.Length); 5628span = span.Slice(pos + 1); 5648span = span.Slice(pos + 1); 5672span = span.Slice(pos + 1); 5974separatorIndex = _source.Slice(_startNext).IndexOf(_separator); 5979separatorIndex = _source.Slice(_startNext).IndexOfAny(_separatorBuffer); 5984separatorIndex = _source.Slice(_startNext).IndexOf(_separatorBuffer); 5995separatorIndex = _source.Slice(_startNext).IndexOfAny(_searchValues);

115=> span.Slice(ClampStart(span, trimElement)); 436return span.Slice(ClampStart(span, trimElements)); 619return span.Slice(start); 684return span.Slice(start); 746return span.Slice(start);

43HtmlEncode(valueSpan.Slice(index), ref sb); 72HtmlEncode(valueSpan.Slice(index), ref sb); 172HtmlDecode(valueSpan.Slice(index), ref sb); 197HtmlDecode(valueSpan.Slice(index), ref sb); 214ReadOnlySpan<char> inputSlice = input.Slice(i + 1); 949char value = (char)BinaryPrimitives.ReadUInt16LittleEndian(tableData.Slice(sizeof(ulong))); 951tableData = tableData.Slice(sizeof(ulong) + sizeof(char));

339value = value.Slice(index); 1022valueTrim = valueTrim.Slice(positiveSign.Length); 1043if (SpanEqualsOrdinalIgnoreCase(valueTrim.Slice(negativeSign.Length), nanSymbol)) 1049if (info.AllowHyphenDuringParsing() && SpanStartsWith(valueTrim, TChar.CastFrom('-')) && SpanEqualsOrdinalIgnoreCase(valueTrim.Slice(1), nanSymbol))

343stringToEscape = stringToEscape.Slice(charsConsumed); 355stringToEscape = stringToEscape.Slice(1); 368stringToEscape = stringToEscape.Slice(charsToCopy);

45uint hashAlgID = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(4)); 46uint cbPublicKey = BinaryPrimitives.ReadUInt32LittleEndian(publicKeyBlob.Slice(8));

153ReadOnlySpan<char> value = component.Slice(separatorIndex + 1).Trim(); 165value = value.Slice(1);

82span = span.Slice(offset); 120span = span.Slice(offset);

28ReadOnlySpan<char> remaining = span.Slice(i);

335span = span.Slice(pos + 1);

983return GetNonRandomizedHashCodeOrdinalIgnoreCaseSlow(hash1, hash2, span.Slice(span.Length - length));

1244searchSpace = searchSpace.Slice(index + matchLength); 1556remaining = remaining.Slice(idx + stride); 1618text = text.Slice(idx + stride); 1646remaining = remaining.Slice(idx + stride); 2222source = source.Slice(index + separator.Length);

403Ascii.FromUtf16(chars.Slice(idx), bytes.Slice(idx), out int charsConsumed); 413chars = chars.Slice(numElementsToConvert); 692Ascii.ToUtf16(bytes.Slice(idx), chars.Slice(idx), out int bytesConsumed); 701bytes = bytes.Slice(numElementsToConvert);

135ReadOnlySpan<char> remainder = format.Slice(pos);

234chars: new ReadOnlySpan<char>(pCharsOriginal, originalCharCount).Slice(charsConsumedSoFar), 263ReadOnlySpan<char> chars = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar); 266chars = chars.Slice(charsConsumedJustNow); 282chars = chars.Slice(charsConsumedJustNow); 356chars = chars.Slice(charsConsumedThisIteration); 379chars = chars.Slice(charsConsumedThisIteration); 498chars: new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar), 531ReadOnlySpan<char> chars = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar); 536chars = chars.Slice(charsConsumedJustNow); // whether or not the drain finished, we may have made some progress 555chars = chars.Slice(charsConsumedJustNow); 639chars = chars.Slice(charsConsumedThisIteration); 661chars = chars.Slice(charsConsumedThisIteration); 828bytes: new ReadOnlySpan<byte>(pBytesOriginal, originalByteCount).Slice(bytesConsumedSoFar), 857ReadOnlySpan<byte> bytes = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar); 865bytes = bytes.Slice(bytesConsumedJustNow); 882bytes = bytes.Slice(bytesConsumedJustNow); 952bytes = bytes.Slice(bytesConsumedThisIteration); 975bytes = bytes.Slice(bytesConsumedThisIteration); 1094bytes: new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar), 1133ReadOnlySpan<byte> bytes = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar); 1142bytes = bytes.Slice(bytesConsumedJustNow); 1158bytes = bytes.Slice(bytesConsumedJustNow); 1243bytes = bytes.Slice(bytesConsumedThisIteration); 1261bytes = bytes.Slice(bytesConsumedThisIteration);

670return DecodeFromUtf8(source.Slice(index), out value, out bytesConsumed); 716source = source.Slice(index);

229_remaining = _remaining.Slice(length); 234_remaining = _remaining.Slice(1); 303_remaining = _remaining.Slice(charsConsumed);

67_remaining = remaining.Slice(idx + stride);

50_remaining = _remaining.Slice(_current.Utf16SequenceLength);

2156remainingChunk = remainingChunk.Slice(foundPos + oldValue.Length);

504buffer = buffer.Slice(bytesConsumed);

229_decoder(_buffer.Slice(CurrentCodeUnitOffset), out Rune thisRune, out _codeUnitLengthOfCurrentScalar);

108source = source.Slice((int)(pInputBufferRemaining - (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source))) + 1); 198source = source.Slice((int)(pInputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)))); 202source = source.Slice(bytesConsumedJustNow); 283source = source.Slice((int)(pInputBufferRemaining - (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(source)))); 301source = source.Slice(bytesConsumedJustNow);

651bytes = bytes.Slice(bytesRead);

787offset = offset.Slice(1); 983ReadOnlySpan<char> weekDaySpan = dateRule.Slice(monthWeekDotIndex + 1); 989int.TryParse(weekDaySpan.Slice(weekDayDotIndex + 1), out int day))

535name = name.Slice(name.LastIndexOf('+') + 1);

372int minorEnd = input.Slice(majorEnd + 1).IndexOf(TChar.CastFrom('.')); 376buildEnd = input.Slice(minorEnd + 1).IndexOf(TChar.CastFrom('.')); 380if (input.Slice(buildEnd + 1).Contains(TChar.CastFrom('.'))) 409TryParseComponent(input.Slice(buildEnd + 1), nameof(revision), throwOnFailure, input, out revision) ? 416return TryParseComponent(input.Slice(minorEnd + 1), nameof(build), throwOnFailure, input, out build) ? 424return TryParseComponent(input.Slice(majorEnd + 1), nameof(input), throwOnFailure, input, out minor) ?

355name = name.Slice(_declaringType._nestedNameLength + 1); 360name = name.Slice(idx + 1);

86_inputString = _inputString.Slice(fullTypeNameLength); 255_inputString = _inputString.Slice(candidate.Length);

205ReadOnlySpan<char> trimmed = span.Slice(1).TrimStart(); 211span = trimmed.Slice(1).TrimStart(); 232int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType); 248input = input.Slice(1); 336span = span.Slice(1).TrimStart();

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

266buffer = buffer.Slice(size);

159int indexOfTimeZoneOffset = ticksvalue.Slice(1).IndexOf('+'); 163indexOfTimeZoneOffset = ticksvalue.Slice(1).IndexOf('-');

180hostname = hostname.Slice(dotIndex + 1);

107span.Slice(i),

3189if ((cF & Flags.AuthorityFound) != 0 && !str.Slice(schemeLength).StartsWith("://", StringComparison.Ordinal)) 3482original = original.Slice(pathLength); 3497IriHelper.EscapeUnescapeIri(ref vsb, original.Slice(fragmentOffset), isQuery: false); // Fragment 3713ReadOnlySpan<char> slice = str.Slice(i); 3737if (ch == '[' && (syntaxFlags & UriSyntaxFlags.AllowIPv6Host) != 0 && IPv6AddressHelper.IsValid(str.Slice(i), out hostLength)) 3759IPv4AddressHelper.IsValid(str.Slice(i), out hostLength, allowIPv6: false, StaticNotAny(flags, Flags.ImplicitFile), (syntaxFlags & UriSyntaxFlags.V1_UnknownUri) != 0)) 3769DomainNameHelper.IsValid(str.Slice(i), iri: false, StaticNotAny(flags, Flags.ImplicitFile), out hostLength)) 3784DomainNameHelper.IsValid(str.Slice(i), iri: true, StaticNotAny(flags, Flags.ImplicitFile), out hostLength)) 3810if (UncNameHelper.IsValid(str.Slice(i), StaticNotAny(flags, Flags.ImplicitFile), out hostLength)) 3911int basicHostEnd = str.Slice(i).IndexOfAny('/', '?', '#'); 4452int i = share.Slice(1).IndexOf('/');

523UriHelper.Unescape(charsToUnescape.Slice(indexOfFirstToUnescape), ref vsb); 575UriHelper.Unescape(charsToUnescape.Slice(indexOfFirstToUnescape), ref vsb);

167EscapeStringToBuilder(charsToEscape.Slice(indexOfFirstToEscape), ref vsb, Unreserved, checkExistingEscaped: false); 223EscapeStringToBuilder(charsToEscape.Slice(indexOfFirstToEscape), ref vsb, noEscape, checkExistingEscaped); 245EscapeStringToBuilder(stringToEscape.Slice(indexOfFirstToEscape), ref dest, noEscape, checkExistingEscaped); 272stringToEscape = stringToEscape.Slice(charsConsumed); 296stringToEscape = stringToEscape.Slice(3); 302stringToEscape = stringToEscape.Slice(1); 315stringToEscape = stringToEscape.Slice(charsToCopy); 348chars.Slice(i), 357chars = chars.Slice(i); 484chars.Slice(i), 494chars = chars.Slice(i); 586foreach (char c in strToClean.Slice(indexOfPossibleCharToRemove))

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

3502data = data.Slice(2); // we consumed one ANSI whitespace char 3513data = data.Slice(2); // we consumed one char (possibly a high surrogate) 3533data = data.Slice(2); //consumed a low surrogate char

58int numNamed = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(pos)); 136return BinaryPrimitives.ReadInt32LittleEndian(data.Slice(pos)); 139return BinaryPrimitives.ReadInt16LittleEndian(data.Slice(pos));

60_offset = BinaryPrimitives.ReadInt32LittleEndian(binaryAttribute.Slice(2));

178int implValue = BinaryPrimitives.ReadUInt16LittleEndian(binaryAttribute.Slice(2));

680ReadOnlySpan<byte> remaining = buffer.Slice(bytesToCurrent);

355name = name.Slice(_declaringType._nestedNameLength + 1); 360name = name.Slice(idx + 1);

86_inputString = _inputString.Slice(fullTypeNameLength); 255_inputString = _inputString.Slice(candidate.Length);

205ReadOnlySpan<char> trimmed = span.Slice(1).TrimStart(); 211span = trimmed.Slice(1).TrimStart(); 232int length = GetFullTypeNameLength(input.Slice(totalLength), out isNestedType); 336span = span.Slice(1).TrimStart();

80typeSpan1 = typeSpan1.Length > type1.Length ? typeSpan1.Slice(type1.Length + 1).TrimStart(s_whiteSpaceChars) : ReadOnlySpan<char>.Empty; 81typeSpan2 = typeSpan2.Length > type2.Length ? typeSpan2.Slice(type2.Length + 1).TrimStart(s_whiteSpaceChars) : ReadOnlySpan<char>.Empty;

306return !value.Slice(index).ContainsAnyExcept(TChar.CastFrom('\0'));

369intDigits = intDigits.Slice(leadingDigits.Length); 375intDigits = intDigits.Slice(PowersOf1e9.MaxPartialDigits); 1015while (bits.Length < powOfTen.Length + omittedLength || BigIntegerCalculator.Compare(bits.Slice(omittedLength), powOfTen) < 0) 1035BigIntegerCalculator.Divide(bits.Slice(omittedLength), powOfTen, upper, lower.Slice(omittedLength));

298value = value.Slice(offset); 378value.Slice(unalignedBytes).CopyTo(uintBytes); 2685bits.Slice(digitShift).CopyTo(zd); 5167bits.Slice(digitShift).CopyTo(zd);

16source.Slice(start).CopyTo(dest.Slice(start));

524Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 596Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 614BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 634ReadOnlySpan<uint> a1 = left12.Slice(n); 635ReadOnlySpan<uint> b1 = right.Slice(n);

81left = left.Slice(k);

106ReadOnlySpan<uint> valueHigh = value.Slice(n); 303ReadOnlySpan<uint> left2 = left.Slice(n + n); 306ReadOnlySpan<uint> right1 = right.Slice(n); 416ReadOnlySpan<uint> leftHigh = left.Slice(n); 420ReadOnlySpan<uint> rightHigh = right.Slice(n); 493ReadOnlySpan<uint> leftHigh = left.Slice(n); 585v1 = value.Slice(n); 591v2 = value.Slice(n + n);

20Debug.Assert(left.Length <= right.Length || left.Slice(right.Length).ContainsAnyExcept(0u)); 21Debug.Assert(left.Length >= right.Length || right.Slice(left.Length).ContainsAnyExcept(0u)); 40if (ActualLength(right.Slice(left.Length)) > 0) 46if (ActualLength(left.Slice(right.Length)) > 0)

2198if ((closeBracket != (text.Length - 1)) && (((style & NumberStyles.AllowTrailingWhite) == 0) || !text.Slice(closeBracket).IsWhiteSpace()))

98signatureField = signatureField.Slice(1);

145ReadOnlySpan<byte> tradKey = source.Slice(metadata.MLDsaAlgorithm.PublicKeySizeInBytes); 185ReadOnlySpan<byte> tradKey = source.Slice(metadata.MLDsaAlgorithm.PrivateSeedSizeInBytes); 307ReadOnlySpan<byte> tradSig = signature.Slice(AlgorithmDetails.MLDsaAlgorithm.SignatureSizeInBytes);

154byte[] y = source.Slice(1 + fieldWidth).ToArray();

35memory.Span.Slice(1).CopyTo(destination); 78integer = integer.Slice(newStart);

183ReadOnlySpan<byte> afterPadding = source.Slice(10);

48source = source.Slice(pos); 71source = source.Slice(1);

493source.Slice(8).CopyTo(destination);

256inputBuffer = inputBuffer.Slice(whitespaceIndex); 260inputBuffer = inputBuffer.Slice(1);

153y = publicKeyBytes.Slice(1 + key.PrivateKey.Length).ToArray(); 225Y = publicKeyBytes.Slice(1 + fieldWidth).ToArray(), 322primeValue = primeValue.Slice(1); 444curve.G.Y = baseSpan.Slice(1 + primeOrPoly.Length).ToArray();

96s = s.Slice(1);

23return span.Slice(1).ToArray();

247int index = str.Slice(startPosition).IndexOf(value); 611remainingData = remainingData.Slice(BytesPerLine);

55inputBuffer.Slice(inputBuffer.Length - _heldoverCipher.Length).CopyTo(_heldoverCipher);

1129serialNumber.Slice(leadingZeros).CopyTo(newSerialNumber);

485return str.Slice(OidTagPrefix.Length);

1790afterFirstDot = match.Slice(firstDot + 1); 1812if (embeddedSpan.Slice(2).Equals(afterFirstDot, StringComparison.OrdinalIgnoreCase))

198val = val.Slice(1); 210val = val.Slice(1);

78definedCharsBitmapAsLittleEndian = definedCharsBitmapAsLittleEndian.Slice(Vector<byte>.Count); 89thisAllowedCharactersBitmap[i] &= BinaryPrimitives.ReadUInt32LittleEndian(definedCharsBitmapAsLittleEndian.Slice(i * sizeof(uint)));

304OperationStatus runeDecodeStatus = Rune.DecodeFromUtf8(source.Slice(srcIdx), out Rune scalarValue, out int bytesConsumedJustNow); 377data = data.Slice(asciiBytesSkipped); 389data = data.Slice(bytesConsumed);

150ReadOnlySpan<char> remainingInput = value.Slice(indexOfFirstCharToEncode); 172remainingInput = remainingInput.Slice(charsConsumedJustNow); 315OperationStatus status = EncodeUtf8Core(utf8Source.Slice(idxOfFirstByteToEncode), utf8Destination.Slice(idxOfFirstByteToEncode), out int innerBytesConsumed, out int innerBytesWritten, isFinalBlock); 361utf8Source = utf8Source.Slice(bytesConsumedJustNow); 373utf8Source = utf8Source.Slice(bytesConsumedJustNow); 445OperationStatus status = EncodeCore(source.Slice(idxOfFirstCharToEncode), destination.Slice(idxOfFirstCharToEncode), out int innerCharsConsumed, out int innerCharsWritten, isFinalBlock); 477source = source.Slice(charsConsumedJustNow); 489source = source.Slice(charsConsumedJustNow); 533value = value.Slice(charsConsumedJustNow); 570utf8Text = utf8Text.Slice(bytesConsumed);

114ReadOnlySpan<char> span = inputSpan.Slice(pos); 117int indexOfPos = span.Slice(i).IndexOf('{'); 153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 163int iteration = slice.Slice(1).IndexOfAny('{', '}'); 174slice = slice.Slice(iteration); 252ReadOnlySpan<char> span = inputSpan.Slice(pos); 276ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = slice.Slice(iteration); 314slice = inputSpan.Slice(pos); 339slice = slice.Slice(iteration1);

373return JsonReaderHelper.UnescapeAndCompare(segment.Slice(idx), otherUtf8Text.Slice(idx));

192JsonReaderHelper.Unescape(currentPropertyName.Slice(idx), utf8Unescaped, 0, out written); 195if (utf8Unescaped.Slice(0, written).SequenceEqual(propertyName.Slice(idx)))

349leftLast = leftFractional.Slice(-diff); 352rightMiddle = rightIntegral.Slice(rightOffset); 368leftMiddle = leftIntegral.Slice(leftOffset); 372rightLast = rightFractional.Slice(diff); 410span = span.Slice(1); 431span = span.Slice(i + 1); 448if (!Utf8Parser.TryParse(span.Slice(i + 1), out exp, out _)) 472frac = frac.Slice(lz + 1);

258return ParseOffset(ref parseData, source.Slice(sourceIndex)); 291return ParseOffset(ref parseData, source.Slice(sourceIndex)); 349return ParseOffset(ref parseData, source.Slice(sourceIndex)); 374|| !TryGetNextTwoDigits(offsetData.Slice(3), ref parseData.OffsetMinutes))

506ReadOnlySpan<byte> remaining = source.Slice(idx);

598if (other.Slice(matchedSoFar).StartsWith(span)) 628return JsonReaderHelper.UnescapeAndCompare(localSpan.Slice(idx), other.Slice(idx)); 658if (!other.Slice(matchedSoFar).StartsWith(span.Slice(0, idx))) 664other = other.Slice(matchedSoFar); 678if (!other.Slice(matchedSoFar).StartsWith(span)) 988if (!TryGetNumber(localBuffer.Slice(_consumed), out int numberOfBytes)) 1135ReadOnlySpan<byte> span = _buffer.Slice(_consumed); 1207if (!TryGetNumber(_buffer.Slice(_consumed), out int consumed)) 1285ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2317ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2324return SkipSingleLineComment(localBuffer.Slice(1), out _); 2328return SkipMultiLineComment(localBuffer.Slice(1), out _); 2422localBuffer = localBuffer.Slice(idx + 1); 2452int foundIdx = localBuffer.Slice(idx).IndexOf(JsonConstants.Slash); 2494ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2501return ConsumeSingleLineComment(localBuffer.Slice(1), _consumed); 2505return ConsumeMultiLineComment(localBuffer.Slice(1), _consumed);

360if (!TryGetNumberMultiSegment(_buffer.Slice(_consumed), out int numberOfBytes)) 512ReadOnlySpan<byte> span = _buffer.Slice(_consumed); 567ReadOnlySpan<byte> leftToMatch = literal.Slice(span.Length); 615leftToMatch = leftToMatch.Slice(span.Length); 680if (!TryGetNumberMultiSegment(_buffer.Slice(_consumed), out int consumed)) 757ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2243ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed); 2276localBuffer = localBuffer.Slice(1); 2449localBuffer = localBuffer.Slice(p); 2482localBuffer = localBuffer.Slice(1); 2540localBuffer = localBuffer.Slice(1); 2552localBuffer = localBuffer.Slice(nextIdx);

503span = span.Slice(pos + 1);

86originalSpan.Slice(checked((int)resumptionByteIndex)),

326rest = rest.Slice(i + 1).TrimStart();

98ThrowHelper.ThrowArgumentException_InvalidUTF8(value.Slice(encoderBytesWritten)); 121value = value.Slice(indexOfFirstByteToEscape); 151value = value.Slice(indexOfFirstByteToEscape); 239value = value.Slice(indexOfFirstByteToEscape); 269value = value.Slice(indexOfFirstByteToEscape);

87value = value.Slice(charsConsumed - partialStringDataBuffer.Length); 93value = value.Slice(charsConsumed - partialStringDataBuffer.Length); 155PartialUtf16StringData = value.Slice(consumed); 255utf8Value = utf8Value.Slice(bytesConsumed - partialStringDataBuffer.Length); 261utf8Value = utf8Value.Slice(bytesConsumed - partialStringDataBuffer.Length); 321PartialUtf8StringData = utf8Value.Slice(consumed); 411bytes = bytes.Slice(3 - partialStringDataBuffer.Length); 438PartialBase64StringData = bytes.Slice(bytes.Length - leftoverSize);

99rest = remainingText.Slice(lineLength + 1);

543int newline = textSpan.Slice(pos).IndexOf('\n'); 619int i = textSpan.Slice(pos).IndexOf(LeadingPrefix.AsSpan()); 634int i = textSpan.Slice(pos).IndexOf(LeadingPrefix.AsSpan(), StringComparison.OrdinalIgnoreCase); 651ReadOnlySpan<char> span = textSpan.Slice(pos); 695int i = textSpan.Slice(pos + FixedDistanceLiteral.Distance).IndexOf(FixedDistanceLiteral.Char); 710int i = textSpan.Slice(pos + FixedDistanceLiteral.Distance).IndexOf(FixedDistanceLiteral.String.AsSpan()); 727int i = textSpan.Slice(pos).IndexOfAny(LeadingStrings); 752ReadOnlySpan<char> textSpanAtOffset = textSpan.Slice(offset); 828ReadOnlySpan<char> slice = textSpan.Slice(startingPos);

173input = input.Slice(indexOfMetachar); 200input = input.Slice(1);

173input = input.Slice(indexOfMetachar); 200input = input.Slice(1);

152chars = chars.Slice(i + 1); 448foreach (byte b in bytes.Slice(i))

91int i = inputSpan.Slice(pos).IndexOfAnyExcept(Utilities.s_whitespace); 111ReadOnlySpan<char> slice = inputSpan.Slice(pos); 126slice = slice.Slice(iteration);

91int i = inputSpan.Slice(pos).IndexOfAnyExcept(Utilities.s_whitespace); 111ReadOnlySpan<char> slice = inputSpan.Slice(pos); 126slice = slice.Slice(iteration);

93ReadOnlySpan<char> span = inputSpan.Slice(pos); 96int indexOfPos = span.Slice(i).IndexOf('{'); 133ReadOnlySpan<char> slice = inputSpan.Slice(pos);

61nameSlice = nameSlice.Slice(escapedComma + 2); 107int tokenEnding = assemblyName.Slice(versionIndex + 1).IndexOf(',') + 1; 108int tokenLength = tokenEnding == 0 ? assemblyName.Slice(versionIndex).Length : tokenEnding; 117int tokenEnding = assemblyName.Slice(tokenIndex + 1).IndexOf(',') + 1; 118int tokenLength = tokenEnding == 0 ? assemblyName.Slice(tokenIndex).Length : tokenEnding;

161subscript = typeName.Slice(openBracketNdx);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

142int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_6561199BCBB8490829F71D3C0AB5A8D82E7C7C1A521E49F6E6880A55FADC7161); 163ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = slice.Slice(iteration); 194slice = inputSpan.Slice(pos); 211slice = slice.Slice(iteration1); 313ReadOnlySpan<char> slice = inputSpan.Slice(pos); 334slice = slice.Slice(iteration); 346int iteration1 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 357slice = slice.Slice(iteration1); 456ReadOnlySpan<char> slice = inputSpan.Slice(pos); 468slice = inputSpan.Slice(pos); 486slice = inputSpan.Slice(pos); 491slice = inputSpan.Slice(pos); 523slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);

145ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 335source.Slice(sourceIndex).CopyTo(remaining);

95chars = chars.Slice(consumedInThisIteration); 113chars = chars.Slice(indexOfFirstNonSpace); 148chars = chars.Slice(consumedFromChars);