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

33content = content.Slice(1);

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

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

33content = content.Slice(1);

33content = content.Slice(1);

116int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_389100A15AF606B196735968A2C9BDA765D89CC46DA25FFC170113259226BFAE); 137ReadOnlySpan<char> slice = inputSpan.Slice(pos); 149slice = inputSpan.Slice(pos); 166slice = slice.Slice(iteration); 258int i = inputSpan.Slice(pos).IndexOf('"'); 279ReadOnlySpan<char> slice = inputSpan.Slice(pos); 293slice = inputSpan.Slice(pos);

104public ulong GetUInt64(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt64LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt64BigEndian(Data.Span.Slice((int)offset)); 105public uint GetUInt32(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt32LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt32BigEndian(Data.Span.Slice((int)offset)); 106public ushort GetUInt16(long offset) => LittleEndian ? BinaryPrimitives.ReadUInt16LittleEndian(Data.Span.Slice((int)offset)) : BinaryPrimitives.ReadUInt16BigEndian(Data.Span.Slice((int)offset)); 341var nameStart = NamesPool.Span.Slice((int)stringIdx);

154ReadOnlySpan<char> slice = inputSpan.Slice(pos); 180slice = inputSpan.Slice(pos); 198slice = slice.Slice(iteration); 220slice = inputSpan.Slice(pos); 245slice = inputSpan.Slice(pos); 263slice = slice.Slice(iteration1); 285slice = inputSpan.Slice(pos); 310slice = inputSpan.Slice(pos); 326slice = slice.Slice(iteration2); 338slice = inputSpan.Slice(pos); 347slice = inputSpan.Slice(pos); 366slice = slice.Slice(iteration3); 387slice = inputSpan.Slice(pos); 507int i = inputSpan.Slice(pos).IndexOf('\\'); 528ReadOnlySpan<char> slice = inputSpan.Slice(pos); 549slice = inputSpan.Slice(pos); 554slice = inputSpan.Slice(pos); 581slice = inputSpan.Slice(pos); 585slice = inputSpan.Slice(pos);

182error = error.Slice(foundIndex + part.Length);

95int i = inputSpan.Slice(pos).IndexOf('\\'); 116ReadOnlySpan<char> slice = inputSpan.Slice(pos); 137slice = inputSpan.Slice(pos); 142slice = inputSpan.Slice(pos); 169slice = inputSpan.Slice(pos); 173slice = inputSpan.Slice(pos);

182error = error.Slice(foundIndex + part.Length);

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);

2503var valueBytes = bytes.AsSpan().Slice(1); 3309value = value.Slice(2);

527byte[] overflow = _bufferWriter.WrittenSpan.Slice(_lastListMemberStart).ToArray();

138string resourceStringName = System.Text.Encoding.UTF8.GetString(method.Name.AsSpan().Slice(4));

33if (!name.Slice(name.Length - metadataTypeName.Length).Equals(metadataTypeName.AsSpan(), StringComparison.Ordinal))

141ReadOnlySpan<byte> currentBuffer = _sectionData._buffers[_bufferIndex].Span.Slice(_bufferPosition);

44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))

33if (!name.Slice(name.Length - metadataTypeName.Length).Equals(metadataTypeName.AsSpan(), StringComparison.Ordinal))

141ReadOnlySpan<byte> currentBuffer = _sectionData._buffers[_bufferIndex].Span.Slice(_bufferPosition);

4888ReadOnlySpan<char> partialMethodName = methodName.Slice(45); 4892partialMethodName = partialMethodName.Slice(15); 4896methodName = partialMethodName.Slice(7); 4901partialMethodName = partialMethodName.Slice(25); 4905methodName = partialMethodName.Slice(9); 4911methodName = partialMethodName.Slice(10);

44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))

44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))

44if (!BinaryPrimitives.TryReadUInt16LittleEndian(_ilBytes.Slice(_currentOffset), out ushort value)) 53if (!BinaryPrimitives.TryReadUInt32LittleEndian(_ilBytes.Slice(_currentOffset), out uint value)) 67if (!BinaryPrimitives.TryReadUInt64LittleEndian(_ilBytes.Slice(_currentOffset), out ulong value)) 76if (!BinaryPrimitives.TryReadSingleLittleEndian(_ilBytes.Slice(_currentOffset), out float value)) 85if (!BinaryPrimitives.TryReadDoubleLittleEndian(_ilBytes.Slice(_currentOffset), out double value)) 118if (!BinaryPrimitives.TryReadInt32LittleEndian(_ilBytes.Slice(_currentOffset), out int value))

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);

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

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();

93int i = inputSpan.Slice(pos).IndexOf(','); 114ReadOnlySpan<char> slice = inputSpan.Slice(pos); 118slice = inputSpan.Slice(pos); 147slice = inputSpan.Slice(pos);

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

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

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

162ReadOnlySpan<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);

190startIndex = span.Slice(startIndex).IndexOf('/') + startIndex; 191endIndex = span.Slice(startIndex + 1).IndexOf('/') + startIndex;

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);

670var currentPath = refPath.AsSpan().Slice(OpenApiConstants.RefPrefix.Length); 682var currentPathWithoutSlash = currentPath.Slice(1); 695: currentPathWithoutSlash.Slice(indexOfNextPath);

195buffer = buffer.Slice(charsUsed);

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

107buffer = buffer.Slice(toWrite);

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

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

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

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

568return span.Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase);

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

978return span.Slice(index + 1).Trim().Equals("chunked", StringComparison.OrdinalIgnoreCase);

240source = source.Slice(charsUsed);

147source = source.Slice(writable);

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);

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);

466var index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark, BytePercentage); 474index = requestLine.Slice(offset).IndexOfAny(ByteSpace, ByteQuestionMark); 531var remaining = requestLine.Slice(offset);

628dataToFrame = dataToFrame.Slice(currentSize);

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);

950ReadOnlySpan<char> slice = inputSpan.Slice(pos); 969slice = slice.Slice(iteration); 989slice = inputSpan.Slice(pos); 1056slice = slice.Slice(iteration1); 1067slice = inputSpan.Slice(pos); 1088slice = inputSpan.Slice(pos); 1097slice = slice.Slice(1); 1110int iteration2 = slice.Slice(1).IndexOf(':'); 1116slice = slice.Slice(iteration2); 1121slice = inputSpan.Slice(pos); 1130slice = inputSpan.Slice(pos); 1148slice = slice.Slice(iteration3); 1203slice = inputSpan.Slice(pos); 1219slice = inputSpan.Slice(pos); 1292slice = inputSpan.Slice(pos); 1315slice = inputSpan.Slice(pos); 1321slice = inputSpan.Slice(pos); 1328slice = inputSpan.Slice(pos); 1342slice = inputSpan.Slice(pos); 1414!slice.Slice(1).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 1420slice = inputSpan.Slice(pos); 1426!slice.Slice(1).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 1432slice = inputSpan.Slice(pos); 1468slice = inputSpan.Slice(pos); 1477slice = slice.Slice(iteration4); 1497slice = inputSpan.Slice(pos); 1517slice = slice.Slice(iteration5); 1537slice = inputSpan.Slice(pos); 1584slice = inputSpan.Slice(pos); 1610slice = slice.Slice(iteration6); 1623slice = inputSpan.Slice(pos); 1636slice = slice.Slice(iteration7); 1655slice = inputSpan.Slice(pos); 1778ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1797slice = slice.Slice(iteration); 1817slice = inputSpan.Slice(pos); 1841slice = slice.Slice(iteration1); 1862slice = inputSpan.Slice(pos); 1887slice = inputSpan.Slice(pos); 1902slice = slice.Slice(iteration2); 1918slice = inputSpan.Slice(pos); 1929slice = slice.Slice(iteration3); 1958slice = inputSpan.Slice(pos); 1979!slice.Slice(2).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 1985slice = inputSpan.Slice(pos); 1991!slice.Slice(2).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 1997slice = inputSpan.Slice(pos); 2017slice = inputSpan.Slice(pos); 2028slice = slice.Slice(iteration4); 2133ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2168slice = slice.Slice(iteration); 2179slice = inputSpan.Slice(pos); 2201slice = inputSpan.Slice(pos); 2219slice = slice.Slice(iteration1); 2240slice = inputSpan.Slice(pos); 2265slice = inputSpan.Slice(pos); 2276slice = slice.Slice(iteration2); 2292slice = inputSpan.Slice(pos); 2301slice = slice.Slice(iteration3); 2320slice = inputSpan.Slice(pos); 2419ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2440slice = slice.Slice(iteration); 2546ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2567slice = slice.Slice(iteration); 2584slice = inputSpan.Slice(pos); 2595slice = slice.Slice(iteration1); 2701ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2722slice = slice.Slice(iteration); 2739slice = inputSpan.Slice(pos); 2750slice = slice.Slice(iteration1); 2857ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2878slice = slice.Slice(iteration); 2895slice = inputSpan.Slice(pos); 2906slice = slice.Slice(iteration1); 2923slice = inputSpan.Slice(pos); 2934slice = slice.Slice(iteration2); 3042ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3063slice = slice.Slice(iteration); 3080slice = inputSpan.Slice(pos); 3091slice = slice.Slice(iteration1); 3108slice = inputSpan.Slice(pos); 3119slice = slice.Slice(iteration2); 3136slice = inputSpan.Slice(pos); 3147slice = slice.Slice(iteration3); 3257ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3274slice = slice.Slice(iteration); 3288slice = inputSpan.Slice(pos); 3319slice = inputSpan.Slice(pos); 3324slice = inputSpan.Slice(pos); 3339slice = inputSpan.Slice(pos); 3387slice = inputSpan.Slice(pos); 3432slice = inputSpan.Slice(pos); 3441slice = slice.Slice(iteration1); 3460slice = inputSpan.Slice(pos); 3488slice = inputSpan.Slice(pos); 3497slice = slice.Slice(iteration2); 3517slice = inputSpan.Slice(pos); 3552slice = inputSpan.Slice(pos); 3680ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3699slice = slice.Slice(iteration); 3719slice = inputSpan.Slice(pos); 3744slice = slice.Slice(iteration1); 3764slice = inputSpan.Slice(pos); 3788slice = slice.Slice(iteration2); 3801slice = inputSpan.Slice(pos); 3810slice = slice.Slice(iteration3); 3829slice = inputSpan.Slice(pos); 3852slice = inputSpan.Slice(pos); 3858slice = inputSpan.Slice(pos); 3885slice = slice.Slice(iteration4); 3904slice = inputSpan.Slice(pos); 3932slice = inputSpan.Slice(pos); 3941slice = slice.Slice(iteration5); 3961slice = inputSpan.Slice(pos); 3996slice = inputSpan.Slice(pos); 4099int i = inputSpan.Slice(pos).IndexOfAny('-', '/'); 4123ReadOnlySpan<char> slice = inputSpan.Slice(pos); 4140slice = inputSpan.Slice(pos); 4145slice = inputSpan.Slice(pos); 4160slice = inputSpan.Slice(pos); 4199slice = inputSpan.Slice(pos); 4205!slice.Slice(2).StartsWith("rminallogger", StringComparison.OrdinalIgnoreCase)) // Match the string "rminallogger" (ordinal case-insensitive) 4211slice = inputSpan.Slice(pos); 4228slice = inputSpan.Slice(pos); 4253slice = inputSpan.Slice(pos); 4268slice = inputSpan.Slice(pos); 4281!slice.Slice(1).StartsWith("rue", StringComparison.OrdinalIgnoreCase)) // Match the string "rue" (ordinal case-insensitive) 4287slice = inputSpan.Slice(pos); 4293!slice.Slice(1).StartsWith("alse", StringComparison.OrdinalIgnoreCase)) // Match the string "alse" (ordinal case-insensitive) 4299slice = inputSpan.Slice(pos); 4305!slice.Slice(1).StartsWith("uto", StringComparison.OrdinalIgnoreCase)) // Match the string "uto" (ordinal case-insensitive) 4311slice = inputSpan.Slice(pos); 4401int i = inputSpan.Slice(pos).IndexOfAny('-', '/'); 4428ReadOnlySpan<char> slice = inputSpan.Slice(pos); 4445slice = inputSpan.Slice(pos); 4450slice = inputSpan.Slice(pos); 4465slice = inputSpan.Slice(pos); 4496slice = inputSpan.Slice(pos); 4512slice = inputSpan.Slice(pos); 4530slice = inputSpan.Slice(pos); 4544slice = inputSpan.Slice(pos); 4560slice = slice.Slice(iteration); 4646int i = inputSpan.Slice(pos).IndexOfAny('-', '/'); 4670ReadOnlySpan<char> slice = inputSpan.Slice(pos); 4687slice = inputSpan.Slice(pos); 4692slice = inputSpan.Slice(pos); 4707slice = inputSpan.Slice(pos); 4753slice = inputSpan.Slice(pos); 4759!slice.Slice(2).StartsWith("rminalloggerparameters", StringComparison.OrdinalIgnoreCase)) // Match the string "rminalloggerparameters" (ordinal case-insensitive) 4765slice = inputSpan.Slice(pos); 4782slice = inputSpan.Slice(pos); 4798slice = slice.Slice(iteration); 4884int i = inputSpan.Slice(pos).IndexOfAny('-', '/'); 4908ReadOnlySpan<char> slice = inputSpan.Slice(pos); 4925slice = inputSpan.Slice(pos); 4930slice = inputSpan.Slice(pos); 4945slice = inputSpan.Slice(pos); 4991slice = inputSpan.Slice(pos); 4997!slice.Slice(2).StartsWith("nsoleloggerparameters", StringComparison.OrdinalIgnoreCase)) // Match the string "nsoleloggerparameters" (ordinal case-insensitive) 5003slice = inputSpan.Slice(pos); 5020slice = inputSpan.Slice(pos); 5036slice = slice.Slice(iteration); 5122int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_C7DF9B147331011DE7321CD7E62F0D799941853E78E1507F38B4C54A3047DBAA); 5153ReadOnlySpan<char> slice = inputSpan.Slice(pos); 5174slice = slice.Slice(iteration); 5195slice = inputSpan.Slice(pos); 5204slice = slice.Slice(iteration1); 5224slice = inputSpan.Slice(pos); 5256slice = slice.Slice(iteration2); 5274slice = slice.Slice(iteration3); 5293int iteration4 = slice.Slice(1).IndexOf('\''); 5299slice = slice.Slice(iteration4); 5310slice = inputSpan.Slice(pos); 5338slice = slice.Slice(iteration5); 5356slice = slice.Slice(iteration6); 5368int iteration7 = slice.Slice(1).IndexOf('\''); 5374slice = slice.Slice(iteration7); 5385slice = inputSpan.Slice(pos); 5406slice = inputSpan.Slice(pos); 5422slice = slice.Slice(iteration8); 5433slice = inputSpan.Slice(pos); 5514int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_C7DF9B147331011DE7321CD7E62F0D799941853E78E1507F38B4C54A3047DBAA); 5538ReadOnlySpan<char> slice = inputSpan.Slice(pos); 5554slice = slice.Slice(iteration); 5567slice = inputSpan.Slice(pos); 5576slice = slice.Slice(iteration1); 5594slice = inputSpan.Slice(pos); 5607slice = slice.Slice(iteration2); 5625slice = slice.Slice(iteration3); 5637int iteration4 = slice.Slice(1).IndexOf('\''); 5643slice = slice.Slice(iteration4); 5656slice = inputSpan.Slice(pos); 5672slice = slice.Slice(iteration5); 5690slice = slice.Slice(iteration6); 5702int iteration7 = slice.Slice(1).IndexOf('\''); 5708slice = slice.Slice(iteration7); 5719slice = inputSpan.Slice(pos); 5736slice = inputSpan.Slice(pos); 5748slice = slice.Slice(iteration8); 5839ReadOnlySpan<char> slice = inputSpan.Slice(pos); 5855slice = slice.Slice(iteration); 5873slice = slice.Slice(iteration1); 5886slice = inputSpan.Slice(pos); 5895slice = slice.Slice(iteration2); 5915slice = inputSpan.Slice(pos); 5929slice = inputSpan.Slice(pos); 5938slice = slice.Slice(iteration3); 5956slice = inputSpan.Slice(pos); 6059ReadOnlySpan<char> slice = inputSpan.Slice(pos); 6078slice = inputSpan.Slice(pos); 6091slice = slice.Slice(iteration); 6113slice = inputSpan.Slice(pos); 6143slice = slice.Slice(iteration1); 6161slice = slice.Slice(iteration2); 6174slice = inputSpan.Slice(pos); 6187slice = slice.Slice(iteration3); 6208slice = inputSpan.Slice(pos); 6238slice = slice.Slice(iteration4); 6256slice = slice.Slice(iteration5); 6269slice = inputSpan.Slice(pos); 6282slice = slice.Slice(iteration6); 6303slice = inputSpan.Slice(pos); 6333slice = slice.Slice(iteration7); 6351slice = slice.Slice(iteration8); 6364slice = inputSpan.Slice(pos); 6377slice = slice.Slice(iteration9); 6398slice = inputSpan.Slice(pos); 6525ReadOnlySpan<char> slice = inputSpan.Slice(pos); 6548slice = slice.Slice(iteration); 6568slice = inputSpan.Slice(pos); 6592slice = slice.Slice(iteration1); 6605slice = inputSpan.Slice(pos); 6614slice = slice.Slice(iteration2); 6633slice = inputSpan.Slice(pos); 6653slice = slice.Slice(iteration3); 6672slice = inputSpan.Slice(pos); 6784ReadOnlySpan<char> slice = inputSpan.Slice(pos); 6796!slice.Slice(2).StartsWith("ey_local_machine\\software\\microsoft\\microsoft sd", StringComparison.OrdinalIgnoreCase) || // Match the string "ey_local_machine\\software\\microsoft\\microsoft sd" (ordinal case-insensitive) 6798!slice.Slice(51).StartsWith("s\\windows\\v", StringComparison.OrdinalIgnoreCase)) // Match the string "s\\windows\\v" (ordinal case-insensitive) 6807slice = inputSpan.Slice(pos); 6824slice = slice.Slice(iteration); 6838slice = inputSpan.Slice(pos); 6851slice = slice.Slice(iteration1); 6942int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_87123116656DBFAC55A68CA48A3676EB22830F3CA134CD4966EB5BAA09267921); 6962ReadOnlySpan<char> slice = inputSpan.Slice(pos); 6972int iteration = slice.Slice(7).IndexOf('"'); 6978slice = slice.Slice(iteration); 6996slice = slice.Slice(iteration1);

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

556int foundIndex = expression.Slice(index).IndexOf(quoteChar);

947remainder = expressionFunctionAsSpan.Slice(argumentsEndIndex + 1).Trim(); 967remainder = expressionFunctionAsSpan.Slice(nextMethodIndex).Trim();

164input = input.Slice(totalLength);

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

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

109int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_B1A5BEBECC5C8A1E8BF295466F7B4433B7A626CE589BACFA6118E8D9F65D9135); 130ReadOnlySpan<char> slice = inputSpan.Slice(pos); 142slice = inputSpan.Slice(pos); 159slice = slice.Slice(iteration); 179slice = inputSpan.Slice(pos); 184slice = inputSpan.Slice(pos);

261source.Slice(sourceIndex).CopyTo(destination);

674path = sep < 0 ? default : path.Slice(sep + 1); 846int directoryLength = value.Slice(1).IndexOf('/') + 1;

205data = data.Slice(nullIndex + 1); 569data = data.Slice(sizeof(int)); 578data = data.Slice(execPathEnd + 1); 583data = data.Slice(1);

568ReadOnlySpan<char> slice = inputSpan.Slice(pos); 587slice = slice.Slice(iteration); 607slice = inputSpan.Slice(pos); 674slice = slice.Slice(iteration1); 685slice = inputSpan.Slice(pos); 706slice = inputSpan.Slice(pos); 715slice = slice.Slice(1); 728int iteration2 = slice.Slice(1).IndexOf(':'); 734slice = slice.Slice(iteration2); 739slice = inputSpan.Slice(pos); 748slice = inputSpan.Slice(pos); 766slice = slice.Slice(iteration3); 821slice = inputSpan.Slice(pos); 837slice = inputSpan.Slice(pos); 910slice = inputSpan.Slice(pos); 933slice = inputSpan.Slice(pos); 939slice = inputSpan.Slice(pos); 946slice = inputSpan.Slice(pos); 960slice = inputSpan.Slice(pos); 1032!slice.Slice(1).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 1038slice = inputSpan.Slice(pos); 1044!slice.Slice(1).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 1050slice = inputSpan.Slice(pos); 1086slice = inputSpan.Slice(pos); 1095slice = slice.Slice(iteration4); 1115slice = inputSpan.Slice(pos); 1135slice = slice.Slice(iteration5); 1155slice = inputSpan.Slice(pos); 1202slice = inputSpan.Slice(pos); 1228slice = slice.Slice(iteration6); 1241slice = inputSpan.Slice(pos); 1254slice = slice.Slice(iteration7); 1273slice = inputSpan.Slice(pos); 1396ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1415slice = slice.Slice(iteration); 1435slice = inputSpan.Slice(pos); 1459slice = slice.Slice(iteration1); 1480slice = inputSpan.Slice(pos); 1505slice = inputSpan.Slice(pos); 1520slice = slice.Slice(iteration2); 1536slice = inputSpan.Slice(pos); 1547slice = slice.Slice(iteration3); 1576slice = inputSpan.Slice(pos); 1597!slice.Slice(2).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 1603slice = inputSpan.Slice(pos); 1609!slice.Slice(2).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 1615slice = inputSpan.Slice(pos); 1635slice = inputSpan.Slice(pos); 1646slice = slice.Slice(iteration4); 1751ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1786slice = slice.Slice(iteration); 1797slice = inputSpan.Slice(pos); 1819slice = inputSpan.Slice(pos); 1837slice = slice.Slice(iteration1); 1858slice = inputSpan.Slice(pos); 1883slice = inputSpan.Slice(pos); 1894slice = slice.Slice(iteration2); 1910slice = inputSpan.Slice(pos); 1919slice = slice.Slice(iteration3); 1938slice = inputSpan.Slice(pos); 2037ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2058slice = slice.Slice(iteration); 2164ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2185slice = slice.Slice(iteration); 2202slice = inputSpan.Slice(pos); 2213slice = slice.Slice(iteration1); 2319ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2340slice = slice.Slice(iteration); 2357slice = inputSpan.Slice(pos); 2368slice = slice.Slice(iteration1); 2475ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2496slice = slice.Slice(iteration); 2513slice = inputSpan.Slice(pos); 2524slice = slice.Slice(iteration1); 2541slice = inputSpan.Slice(pos); 2552slice = slice.Slice(iteration2); 2660ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2681slice = slice.Slice(iteration); 2698slice = inputSpan.Slice(pos); 2709slice = slice.Slice(iteration1); 2726slice = inputSpan.Slice(pos); 2737slice = slice.Slice(iteration2); 2754slice = inputSpan.Slice(pos); 2765slice = slice.Slice(iteration3); 2856int i = inputSpan.Slice(pos).IndexOfAnyDigit(); 2876ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2891slice = slice.Slice(iteration); 2989ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3010slice = slice.Slice(iteration); 3032slice = slice.Slice(iteration1); 3047slice = inputSpan.Slice(pos); 3058slice = slice.Slice(iteration2); 3165ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3188slice = slice.Slice(iteration); 3208slice = inputSpan.Slice(pos); 3246slice = inputSpan.Slice(pos); 3259slice = slice.Slice(iteration1); 3279slice = inputSpan.Slice(pos); 3326slice = inputSpan.Slice(pos); 3366slice = inputSpan.Slice(pos); 3379slice = slice.Slice(iteration2); 3399slice = inputSpan.Slice(pos); 3446slice = inputSpan.Slice(pos); 3486slice = inputSpan.Slice(pos); 3499slice = slice.Slice(iteration3); 3519slice = inputSpan.Slice(pos); 3566slice = inputSpan.Slice(pos); 3606slice = inputSpan.Slice(pos); 3619slice = slice.Slice(iteration4); 3639slice = inputSpan.Slice(pos); 3686slice = inputSpan.Slice(pos); 3727slice = inputSpan.Slice(pos); 3738slice = slice.Slice(iteration5); 3765slice = inputSpan.Slice(pos); 3862ReadOnlySpan<char> slice = inputSpan.Slice(pos); 3889slice = slice.Slice(iteration); 3906slice = inputSpan.Slice(pos); 3917slice = slice.Slice(iteration1); 3934slice = inputSpan.Slice(pos); 3957slice = inputSpan.Slice(pos); 4060ReadOnlySpan<char> slice = inputSpan.Slice(pos); 4081slice = slice.Slice(iteration); 4103slice = slice.Slice(iteration1); 4118slice = inputSpan.Slice(pos); 4129slice = slice.Slice(iteration2);

409ReadOnlySpan<char> slice = inputSpan.Slice(pos); 428slice = slice.Slice(iteration); 448slice = inputSpan.Slice(pos); 515slice = slice.Slice(iteration1); 526slice = inputSpan.Slice(pos); 547slice = inputSpan.Slice(pos); 556slice = slice.Slice(1); 569int iteration2 = slice.Slice(1).IndexOf(':'); 575slice = slice.Slice(iteration2); 580slice = inputSpan.Slice(pos); 589slice = inputSpan.Slice(pos); 607slice = slice.Slice(iteration3); 662slice = inputSpan.Slice(pos); 678slice = inputSpan.Slice(pos); 751slice = inputSpan.Slice(pos); 774slice = inputSpan.Slice(pos); 780slice = inputSpan.Slice(pos); 787slice = inputSpan.Slice(pos); 801slice = inputSpan.Slice(pos); 873!slice.Slice(1).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 879slice = inputSpan.Slice(pos); 885!slice.Slice(1).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 891slice = inputSpan.Slice(pos); 927slice = inputSpan.Slice(pos); 936slice = slice.Slice(iteration4); 956slice = inputSpan.Slice(pos); 976slice = slice.Slice(iteration5); 996slice = inputSpan.Slice(pos); 1043slice = inputSpan.Slice(pos); 1069slice = slice.Slice(iteration6); 1082slice = inputSpan.Slice(pos); 1095slice = slice.Slice(iteration7); 1114slice = inputSpan.Slice(pos); 1237ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1256slice = slice.Slice(iteration); 1276slice = inputSpan.Slice(pos); 1300slice = slice.Slice(iteration1); 1321slice = inputSpan.Slice(pos); 1346slice = inputSpan.Slice(pos); 1361slice = slice.Slice(iteration2); 1377slice = inputSpan.Slice(pos); 1388slice = slice.Slice(iteration3); 1417slice = inputSpan.Slice(pos); 1438!slice.Slice(2).StartsWith("rror", StringComparison.OrdinalIgnoreCase)) // Match the string "rror" (ordinal case-insensitive) 1444slice = inputSpan.Slice(pos); 1450!slice.Slice(2).StartsWith("arning", StringComparison.OrdinalIgnoreCase)) // Match the string "arning" (ordinal case-insensitive) 1456slice = inputSpan.Slice(pos); 1476slice = inputSpan.Slice(pos); 1487slice = slice.Slice(iteration4); 1592ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1627slice = slice.Slice(iteration); 1638slice = inputSpan.Slice(pos); 1660slice = inputSpan.Slice(pos); 1678slice = slice.Slice(iteration1); 1699slice = inputSpan.Slice(pos); 1724slice = inputSpan.Slice(pos); 1735slice = slice.Slice(iteration2); 1751slice = inputSpan.Slice(pos); 1760slice = slice.Slice(iteration3); 1779slice = inputSpan.Slice(pos); 1878ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1899slice = slice.Slice(iteration); 2005ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2026slice = slice.Slice(iteration); 2043slice = inputSpan.Slice(pos); 2054slice = slice.Slice(iteration1); 2160ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2181slice = slice.Slice(iteration); 2198slice = inputSpan.Slice(pos); 2209slice = slice.Slice(iteration1); 2316ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2337slice = slice.Slice(iteration); 2354slice = inputSpan.Slice(pos); 2365slice = slice.Slice(iteration1); 2382slice = inputSpan.Slice(pos); 2393slice = slice.Slice(iteration2); 2501ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2522slice = slice.Slice(iteration); 2539slice = inputSpan.Slice(pos); 2550slice = slice.Slice(iteration1); 2567slice = inputSpan.Slice(pos); 2578slice = slice.Slice(iteration2); 2595slice = inputSpan.Slice(pos); 2606slice = slice.Slice(iteration3);

158ReadOnlySpan<char> slice = inputSpan.Slice(pos); 175slice = slice.Slice(iteration); 189slice = inputSpan.Slice(pos); 220slice = inputSpan.Slice(pos); 225slice = inputSpan.Slice(pos); 240slice = inputSpan.Slice(pos); 288slice = inputSpan.Slice(pos); 333slice = inputSpan.Slice(pos); 342slice = slice.Slice(iteration1); 361slice = inputSpan.Slice(pos); 389slice = inputSpan.Slice(pos); 398slice = slice.Slice(iteration2); 418slice = inputSpan.Slice(pos); 453slice = inputSpan.Slice(pos); 581ReadOnlySpan<char> slice = inputSpan.Slice(pos); 600slice = slice.Slice(iteration); 620slice = inputSpan.Slice(pos); 645slice = slice.Slice(iteration1); 665slice = inputSpan.Slice(pos); 689slice = slice.Slice(iteration2); 702slice = inputSpan.Slice(pos); 711slice = slice.Slice(iteration3); 730slice = inputSpan.Slice(pos); 753slice = inputSpan.Slice(pos); 759slice = inputSpan.Slice(pos); 786slice = slice.Slice(iteration4); 805slice = inputSpan.Slice(pos); 833slice = inputSpan.Slice(pos); 842slice = slice.Slice(iteration5); 862slice = inputSpan.Slice(pos); 897slice = inputSpan.Slice(pos);

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);

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

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);

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

111int stringLen = miniMdBuffer.Slice((int)(currentAddress - miniMetaDataBuffAddress)).IndexOf((byte)0);

2638moduleSpan = moduleSpan.Slice(pathNameSpanIndex + 1);

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

148int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_96276B01C1276BB5CEEDBDA004C1E358097F2E4790D1CD1FB729AC034B750526); 173ReadOnlySpan<char> slice = inputSpan.Slice(pos); 185slice = inputSpan.Slice(pos); 198slice = slice.Slice(iteration); 218slice = inputSpan.Slice(pos); 244slice = slice.Slice(iteration1); 263slice = inputSpan.Slice(pos); 353int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_F5813B88945F49B45ED7FFDFE9559D9201C0782F73CC2CB43535DF2AFF67A7CE); 378ReadOnlySpan<char> slice = inputSpan.Slice(pos); 390slice = inputSpan.Slice(pos); 403slice = slice.Slice(iteration); 423slice = inputSpan.Slice(pos); 449slice = slice.Slice(iteration1); 468slice = inputSpan.Slice(pos); 556int i = inputSpan.Slice(pos).IndexOfAnyExcept(':'); 577ReadOnlySpan<char> slice = inputSpan.Slice(pos); 593slice = slice.Slice(iteration); 613slice = inputSpan.Slice(pos); 628if (!slice.Slice(1).StartsWith("rror")) 635slice = inputSpan.Slice(pos); 640if (!slice.Slice(1).StartsWith("arning")) 647slice = inputSpan.Slice(pos); 668int iteration1 = slice.Slice(1).IndexOfAnyExcept(Utilities.s_asciiLetters); 680slice = slice.Slice(iteration1); 686int iteration2 = slice.Slice(1).IndexOfAnyExceptInRange('0', '9'); 698slice = slice.Slice(iteration2); 703if (!slice.Slice(1).StartsWith(": ")) 711int iteration3 = slice.Slice(3).IndexOf('\n'); 723slice = slice.Slice(iteration3);

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);

99rest = remainingText.Slice(lineLength + 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('&');

36remaining = remaining.Slice(firstEscapedCharacterIndex); 42remaining = remaining.Slice(1); 52remaining = remaining.Slice(next);

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);

775tokenSpan = 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);

523EncodeToTokensInternal(text.Slice(currentOffset), considerNormalization, ref progressOffset, tokens, buffer, ref normalizedString, ref normalizedStringIndex); 703int codepointLength = Helpers.EncodeNextUtf8(normalizationSpan.Slice(offsetStart), destination); 976EncodeToIdsInternal(text.Slice(currentOffset), considerNormalization, ids, buffer, ref normalizedString, ref normalizedStringIndex, ref charsConsumed, maxTokenCount); 980StoreNormalizedText(text.Slice(currentOffset), considerNormalization, buffer, ref normalizedString, ref normalizedStringIndex); 1356CountTokensInternal(text.Slice(currentOffset), considerNormalization, ref tokenCount, buffer, ref normalizedString, ref normalizedStringIndex, ref charsConsumed, maxTokenCount); 1360StoreNormalizedText(text.Slice(currentOffset), considerNormalization, buffer, ref normalizedString, ref normalizedStringIndex); 1603GetIndexByTokenCountFromEndInternal(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);

445input = input.Slice(p); 475sp = sp.Slice(1); 510input = input.Slice(p); 591blob = blob.Slice(sizeof(uint)); 613normalized = 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);

102ReadOnlySpan<char> slice = inputSpan.Slice(pos); 142ReadOnlySpan<char> slice = inputSpan.Slice(pos); 150slice = inputSpan.Slice(pos); 165slice = inputSpan.Slice(pos); 176slice = slice.Slice(iteration); 203slice = inputSpan.Slice(pos); 208slice = inputSpan.Slice(pos); 221slice = inputSpan.Slice(pos);

248internal static ReadOnlySpan<byte> BundleHeaderSignature => BundleHeaderPlaceholder.Slice(8);

43int typelibGuidEntryOffset = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(OffsetOfGuidOffset)); 44int infoRefsOffsetCount = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(OffsetOfTypeInfosCount)); 47int fileOffset = (int)BinaryPrimitives.ReadUInt32LittleEndian(fileContents.Slice(guidTableOffset)); 60ushort majorVer = BinaryPrimitives.ReadUInt16LittleEndian(span.Slice(OffsetOfMajorVersion)); 61ushort minorVer = BinaryPrimitives.ReadUInt16LittleEndian(span.Slice(OffsetOfMinorVersion));

630remaining = remaining.Slice(length); 644Rune.DecodeFromUtf16(remaining.Slice(i), out Rune rune, out var runeLength); 649remaining = remaining.Slice(length);

109relativePathCandidateMemory.Slice(stem.Length);

224if (!span.Slice(index).StartsWith(part.Value.Span, StringComparison.OrdinalIgnoreCase)) 252var remainingSpan = span.Slice(index + minimumCharactersToConsume); 258remainingSpan = remainingSpan.Slice(nextLiteralIndex + nextPart.Value.Length); 334var remaining = segment.Slice(extensionIndex); 338if (TryMatchExtension(node, remaining.Slice(indexOfDot), out var extensionCandidate))

157var nextVariableIndex = segmentSpan.Slice(variableIndex + 1).IndexOfAny(searchValues);

1144chars = chars.Slice(nullPos + 1);

294span = span.Slice(slashIndex + 1);

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);

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));

354result.AddValue(withoutBrackets.Slice(indexOfColon + 1).ToString());

215tokenList.Add(new Token(alias.Slice(i + 1).ToString(), TokenType.Argument, default, argumentIndex)); 225tokenList.Add(new Token(alias.Slice(i).ToString(), TokenType.Argument, default, argumentIndex)); 240tokenList.Add(new Token(alias.Slice(index).ToString(), TokenType.Argument, default, argumentIndex));

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

93int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_AC244FE541E52CFD90CCD7AB13997D32F9D5031F007841348B9EE5A65488D64E); 113ReadOnlySpan<char> slice = inputSpan.Slice(pos);

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

156ReadOnlySpan<char> slice = inputSpan.Slice(pos); 166slice = inputSpan.Slice(pos); 187slice = inputSpan.Slice(pos); 205slice = slice.Slice(iteration); 224slice = inputSpan.Slice(pos); 231slice = inputSpan.Slice(pos); 253slice = inputSpan.Slice(pos); 337ReadOnlySpan<char> slice = inputSpan.Slice(pos); 353slice = slice.Slice(iteration); 444ReadOnlySpan<char> slice = inputSpan.Slice(pos); 461slice = inputSpan.Slice(pos); 483slice = inputSpan.Slice(pos); 488slice = inputSpan.Slice(pos); 501slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

156ReadOnlySpan<char> slice = inputSpan.Slice(pos); 166slice = inputSpan.Slice(pos); 187slice = inputSpan.Slice(pos); 205slice = slice.Slice(iteration); 224slice = inputSpan.Slice(pos); 231slice = inputSpan.Slice(pos); 253slice = inputSpan.Slice(pos); 337ReadOnlySpan<char> slice = inputSpan.Slice(pos); 353slice = slice.Slice(iteration); 444ReadOnlySpan<char> slice = inputSpan.Slice(pos); 461slice = inputSpan.Slice(pos); 483slice = inputSpan.Slice(pos); 488slice = inputSpan.Slice(pos); 501slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

156ReadOnlySpan<char> slice = inputSpan.Slice(pos); 166slice = inputSpan.Slice(pos); 187slice = inputSpan.Slice(pos); 205slice = slice.Slice(iteration); 224slice = inputSpan.Slice(pos); 231slice = inputSpan.Slice(pos); 253slice = inputSpan.Slice(pos); 337ReadOnlySpan<char> slice = inputSpan.Slice(pos); 353slice = slice.Slice(iteration); 444ReadOnlySpan<char> slice = inputSpan.Slice(pos); 461slice = inputSpan.Slice(pos); 483slice = inputSpan.Slice(pos); 488slice = inputSpan.Slice(pos); 501slice = inputSpan.Slice(pos); 535slice = inputSpan.Slice(pos);

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

117ReadOnlySpan<char> nextBaggageSpan = entrySeparator >= 0 ? baggageSpan.Slice(entrySeparator + 1) : ReadOnlySpan<char>.Empty; 127ReadOnlySpan<char> valueSpan = currentEntry.Slice(keyValueSeparator + 1); 170traceStateSpan = commaIndex >= 0 ? traceStateSpan.Slice(commaIndex + 1) : ReadOnlySpan<char>.Empty; 195ReadOnlySpan<char> value = entry.Slice(equalIndex + 1); 317if (!TryDecodeEscapedByte(valueSpan.Slice(i), out byte b0)) 332if (i + 5 >= valueSpan.Length || valueSpan[i + 3] != Percent || !TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || (b1 & 0xC0) != 0x80) 351!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 352!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 373!TryDecodeEscapedByte(valueSpan.Slice(i + 3), out byte b1) || 374!TryDecodeEscapedByte(valueSpan.Slice(i + 6), out byte b2) || 375!TryDecodeEscapedByte(valueSpan.Slice(i + 9), out byte b3) ||

149ReadOnlySpan<byte> dataSpan = data.Slice(pos); 163dataSpan = data.Slice(pos); 1414dataSpan = data.Slice(pos); 1430dataSpan = data.Slice(pos); 1451dataSpan = data.Slice(pos); 1482samples[index].SetInstanceValue(0, data.Slice(pos)); 1491dataSpan = data.Slice(pos); 1498string instanceName = PERF_INSTANCE_DEFINITION.GetName(in perfInstance, data.Slice(pos)).ToString(); 1523samples[index].SetInstanceValue(i, data.Slice(pos)); 1525dataSpan = data.Slice(pos); 1550dataSpan = data.Slice(pos); 1566dataSpan = data.Slice(pos); 1580dataSpan = data.Slice(pos); 1590dataSpan = data.Slice(pos); 1594instanceNames[i] = PERF_INSTANCE_DEFINITION.GetName(in perfInstance, data.Slice(pos)).ToString(); 1597dataSpan = data.Slice(pos); 1716return (long)BitConverter.ToUInt32(data.Slice(_offset)); 1720return BitConverter.ToInt64(data.Slice(_offset));

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

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

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

354unconsumedBytes = unconsumedBytes.Slice(SkipPreambleOrDetectEncoding(unconsumedBytes, ref encoding, ref decoder));

237bytes = bytes.Slice(SkipPreambleOrDetectEncoding(bytes, ref encoding, ref decoder));

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));

113Vector<ushort> lower = new Vector<ushort>(source.Slice(position)); 114Vector<ushort> upper = new Vector<ushort>(source.Slice(position + Vector<ushort>.Count)); 148Vector<byte> source = new Vector<byte>(bytes.Slice(position));

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));

295private 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));

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

181encodedValue = encodedValue.Slice(1);

20path = path.Slice(nonSlash);

700line = line.Slice(spacePos + 1); 710ReadOnlySpan<byte> valueSlice = line.Slice(equalPos + 1); 717buffer = buffer.Slice(newlinePos + 1);

422name = pathNameBytes.Slice(lastIdx + 1); 436name = pathNameBytes.Slice(lastIdx + 1);

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

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

233while (ZipGenericExtraField.TryReadBlock(extraFieldData.Slice(totalBytesConsumed), out int currBytesConsumed, out ZipGenericExtraField currentExtraField)) 314data = data.Slice(FieldLengths.UncompressedSize); 318data = data.Slice(FieldLengths.UncompressedSize); 333data = data.Slice(FieldLengths.CompressedSize); 337data = data.Slice(FieldLengths.CompressedSize); 352data = data.Slice(FieldLengths.LocalHeaderOffset); 356data = data.Slice(FieldLengths.LocalHeaderOffset); 779ushort fieldSize = BinaryPrimitives.ReadUInt16LittleEndian(extraFieldData.Slice(2)); 780extraFieldData = extraFieldData.Slice(4); 793extraFieldData = extraFieldData.Slice(fieldSize);

143buffer = buffer.Slice(bytesConsumed);

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

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

97buffer = buffer.Slice(bytesConsumed);

61path = path.Slice(nonSlash);

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

234source = source.Slice(k);

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

83x2 = Vector128.Create<byte>(remaining.Slice(16)).AsUInt64(); 84Vector128<ulong> x3 = Vector128.Create<byte>(remaining.Slice(32)).AsUInt64(); 85Vector128<ulong> x4 = Vector128.Create<byte>(remaining.Slice(48)).AsUInt64(); 87remaining = remaining.Slice(Vector128<byte>.Count * 4); 94Vector128<ulong> y6 = Vector128.Create<byte>(remaining.Slice(16)).AsUInt64(); 95Vector128<ulong> y7 = Vector128.Create<byte>(remaining.Slice(32)).AsUInt64(); 96Vector128<ulong> y8 = Vector128.Create<byte>(remaining.Slice(48)).AsUInt64(); 103remaining = remaining.Slice(Vector128<byte>.Count * 4); 115remaining = remaining.Slice(Vector128<byte>.Count); 122remaining = remaining.Slice(Vector128<byte>.Count); 216Vector128<ulong> x2 = LoadReversed(remaining.Slice(16)); 217Vector128<ulong> x3 = LoadReversed(remaining.Slice(32)); 218Vector128<ulong> x4 = LoadReversed(remaining.Slice(48)); 220remaining = remaining.Slice(Vector128<byte>.Count * 4); 227Vector128<ulong> y6 = LoadReversed(remaining.Slice(16)); 228Vector128<ulong> y7 = LoadReversed(remaining.Slice(32)); 229Vector128<ulong> y8 = LoadReversed(remaining.Slice(48)); 236remaining = remaining.Slice(Vector128<byte>.Count * 4); 248remaining = remaining.Slice(Vector128<byte>.Count); 255remaining = remaining.Slice(Vector128<byte>.Count);

145source = source.Slice(sizeof(ulong)); 167source = source.Slice(sizeof(uint)); 205source = source.Slice(sizeof(ulong)); 213source = source.Slice(sizeof(uint));

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

92Vector128<ulong> x2 = Vector128.Create<byte>(remaining.Slice(16)).AsUInt64(); 93Vector128<ulong> x3 = Vector128.Create<byte>(remaining.Slice(32)).AsUInt64(); 94Vector128<ulong> x4 = Vector128.Create<byte>(remaining.Slice(48)).AsUInt64(); 96remaining = remaining.Slice(Vector128<byte>.Count * 4); 103Vector128<ulong> y6 = Vector128.Create<byte>(remaining.Slice(16)).AsUInt64(); 104Vector128<ulong> y7 = Vector128.Create<byte>(remaining.Slice(32)).AsUInt64(); 105Vector128<ulong> y8 = Vector128.Create<byte>(remaining.Slice(48)).AsUInt64(); 112remaining = remaining.Slice(Vector128<byte>.Count * 4); 124remaining = remaining.Slice(Vector128<byte>.Count); 131remaining = remaining.Slice(Vector128<byte>.Count); 219Vector128<ulong> x2 = LoadReversed(remaining.Slice(16)); 220Vector128<ulong> x3 = LoadReversed(remaining.Slice(32)); 221Vector128<ulong> x4 = LoadReversed(remaining.Slice(48)); 223remaining = remaining.Slice(Vector128<byte>.Count * 4); 230Vector128<ulong> y6 = LoadReversed(remaining.Slice(16)); 231Vector128<ulong> y7 = LoadReversed(remaining.Slice(32)); 232Vector128<ulong> y8 = LoadReversed(remaining.Slice(48)); 239remaining = remaining.Slice(Vector128<byte>.Count * 4); 251remaining = remaining.Slice(Vector128<byte>.Count); 258remaining = remaining.Slice(Vector128<byte>.Count);

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));

141ReadOnlySpan<ulong> defaultSecret3UInt64 = MemoryMarshal.Cast<byte, ulong>(DefaultSecret.Slice(3)); 327source.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('"');

1217source = 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);

127data = Vector.Create(span.Slice(Vector<T>.Count)); 131data = Vector.Create(span.Slice(Vector<T>.Count * 2)); 135data = Vector.Create(span.Slice(Vector<T>.Count * 3)); 139span = span.Slice(Vector<T>.Count * 4); 150span = span.Slice(Vector<T>.Count);

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);

469span = span.Slice(3);

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);

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

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

342ValidateChunkExtension(currentLine.Slice(bytesConsumed));

725frameData = frameData.Slice(1); 743frameData = frameData.Slice(FrameHeader.PriorityInfoLength); 765span = span.Slice(2); 773span = span.Slice(originLength); 855settings = settings.Slice(2); 857settings = settings.Slice(4); 1984int streamId = (int)(BinaryPrimitives.ReadUInt32BigEndian(buffer.Slice(5)) & 0x7FFFFFFF);

1259value = value.Slice(1); 1399source = source.Slice(remaining); 1689if (TryFindEndOfLine(_readBuffer.ActiveReadOnlySpan.Slice(searchOffset), out int offset)) 1743buffer = 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);

341AddressFamily.InterNetwork => new IPAddress(BinaryPrimitives.ReadUInt32LittleEndian(remoteAddressSpan.Slice(4))),

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

222written += EncodeBytes(buffer.Slice(written), false, false); 242written += 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)); 725BitConverter.ToUInt32(numbers.Slice(4)), 726BitConverter.ToUInt32(numbers.Slice(8)), 727BitConverter.ToUInt32(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);

560info = info.Slice(length + 4); 576info = info.Slice(length + 4); 871_serverSeal.Transform(input.Slice(SignatureLength), output.Slice(0, input.Length - SignatureLength));

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

220errorCode = Interop.OpenSsl.DoSslHandshake((SafeSslHandle)context, inputBuffer.Slice(consumed), out int c, ref token); 228errorCode = Interop.OpenSsl.DoSslHandshake((SafeSslHandle)context, inputBuffer.Slice(consumed), out int c, ref token);

283if (!TryParseHelloFrame(frame.Slice(HeaderSize), ref info, options, callback)) 391int helloLength = ReadUInt24BigEndian(sslHandshake.Slice(HelloLengthOffset)); 392ReadOnlySpan<byte> helloData = sslHandshake.Slice(HelloOffset); 552info.RawApplicationProtocols = extensionData.Slice(sizeof(short)).ToArray(); 557extensions = extensions.Slice(extensionLength); 579ReadOnlySpan<byte> serverNameList = serverNameListExtension.Slice(ServerNameListOffset); 612ReadOnlySpan<byte> hostNameStruct = serverName.Slice(HostNameStructOffset); 636ReadOnlySpan<byte> hostName = hostNameStruct.Slice(HostNameOffset); 670extensionData = extensionData.Slice(VersionListNameOffset); 685extensionData = extensionData.Slice(VersionLength); 711ReadOnlySpan<byte> alpnList = extensionData.Slice(AlpnListOffset); 747alpnList = alpnList.Slice(protocolLength + 1); 816return (numberOfBytesToSkip < bytes.Length) ? bytes.Slice(numberOfBytesToSkip) : ReadOnlySpan<byte>.Empty;

2171buffer.Slice(totalConsumed),

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

159data = data.Slice(i);

364fieldValue = line.Slice(colonPos + 1); 367fieldValue = fieldValue.Slice(1);

52buffer = buffer.Slice(toCopy);

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

64payload = payload.Slice(consumed);

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

107ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count); 115span = span.Slice(Vector128<T>.Count); 121current = Vector128.Create(x.Slice(start)); 175ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count); 183span = span.Slice(Vector128<T>.Count); 189current = Vector128.Create(x.Slice(start)); 252ReadOnlySpan<T> span = x.Slice(Vector128<T>.Count); 260span = span.Slice(Vector128<T>.Count); 266current = Vector128.Create(x.Slice(start)); 338ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 346span = span.Slice(Vector256<T>.Count); 352current = Vector256.Create(x.Slice(start)); 406ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 414span = span.Slice(Vector256<T>.Count); 420current = Vector256.Create(x.Slice(start)); 483ReadOnlySpan<T> span = x.Slice(Vector256<T>.Count); 491span = span.Slice(Vector256<T>.Count); 497current = Vector256.Create(x.Slice(start)); 569ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 577span = span.Slice(Vector512<T>.Count); 583current = Vector512.Create(x.Slice(start)); 637ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 645span = span.Slice(Vector512<T>.Count); 651current = Vector512.Create(x.Slice(start)); 714ReadOnlySpan<T> span = x.Slice(Vector512<T>.Count); 722span = span.Slice(Vector512<T>.Count); 728current = Vector512.Create(x.Slice(start));

2415tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2427tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2452tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2464tensor.Strides.Slice(dimension).CopyTo(newStrides.Slice(dimension + 1)); 2489tensor.Lengths.Slice(dimension).CopyTo(newLengths.Slice(dimension + 1)); 2501tensor.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);

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

318var remainder = value.Slice(index);

42source = source.Slice(4);

283source = source.Slice(bytesConsumed); 312source = source.Slice(localConsumed); 328source = source.Slice(localConsumed); 522source = source.Slice(1); 544source = source.Slice(encodedIdx); 627source = source.Slice(1); 649source = 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))

1275result = (char)BinaryPrimitives.ReadUInt16BigEndian(source.Slice(source.Length - sizeof(char)));

184valuesAsBytes = valuesAsBytes.Slice(Vector512<byte>.Count); 197valuesAsBytes = valuesAsBytes.Slice(Vector256<byte>.Count); 208Vector128<byte> upperVector = Vector128.Create(valuesAsBytes.Slice(Vector128<byte>.Count)); 216valuesAsBytes = valuesAsBytes.Slice(Vector128<byte>.Count * 2);

2466source = source.Slice(chunkSize);

637int mid = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(4)); 638int hi = BinaryPrimitives.ReadInt32LittleEndian(span.Slice(8)); 639int 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);

197? source.Slice(endIndex) 839text = 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); 5787if (++Index < Length && Value.Slice(Index).StartsWith(str)) 6005Value.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');

697int numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 719numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 741numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 779numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom(',')); 788numLen = guidString.Slice(numStart).IndexOf(TChar.CastFrom('}')); 864guidString = guidString.Slice(1); 869guidString = 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)

338value = value.Slice(sizeof(int)); 343value = value.Slice(sizeof(int)); 348value = value.Slice(sizeof(int)); 357_v2 = Round(_v2, BitConverter.ToUInt32(value.Slice(sizeof(int) * 1))); 358_v3 = Round(_v3, BitConverter.ToUInt32(value.Slice(sizeof(int) * 2))); 359_v4 = Round(_v4, BitConverter.ToUInt32(value.Slice(sizeof(int) * 3))); 362value = value.Slice(sizeof(int) * 4); 370value = value.Slice(sizeof(int));

803result = BinaryPrimitives.ReadInt128BigEndian(source.Slice(source.Length - Size));

351result = BinaryPrimitives.ReadInt16BigEndian(source.Slice(source.Length - sizeof(short)));

372result = BinaryPrimitives.ReadInt32BigEndian(source.Slice(source.Length - sizeof(int)));

369result = BinaryPrimitives.ReadInt64BigEndian(source.Slice(source.Length - sizeof(long)));

398result = BinaryPrimitives.ReadIntPtrBigEndian(source.Slice(source.Length - sizeof(nint_t)));

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);

156buffer = buffer.Slice(bytesWritten);

189destination.Write(_memory.Span.Slice(_position));

510source = source.Slice(numBytes);

152ReadOnlySpan<char> remaining = _text.Span.Slice(_charPosition);

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);

261data = data.Slice(Vector128<T>.Count); 266data = data.Slice(Vector128<T>.Count); 268best128 = TMinMax.Compare(best, Vector128.Create(span.Slice(span.Length - Vector128<T>.Count))); 274data = data.Slice(Vector256<T>.Count); 279data = data.Slice(Vector256<T>.Count); 281best = TMinMax.Compare(best, Vector256.Create(span.Slice(span.Length - Vector256<T>.Count))); 290data = data.Slice(Vector512<T>.Count); 295data = data.Slice(Vector512<T>.Count); 297best = TMinMax.Compare(best, Vector512.Create(span.Slice(span.Length - Vector512<T>.Count)));

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));

383value = value.Slice(index); 1040ReadOnlySpan<TChar> afterSign = valueTrim.Slice(positiveSign.Length); 1063ReadOnlySpan<TChar> afterSign = valueTrim.Slice(negativeSign.Length); 1074ReadOnlySpan<TChar> afterHyphen = valueTrim.Slice(1); 1185ReadOnlySpan<TChar> trailing = SpanTrimStart(candidate.Slice(symbol.Length)); 1231if (!negativeSign.IsEmpty && value.Slice(index).StartsWith(negativeSign)) 1244if (!positiveSign.IsEmpty && value.Slice(index).StartsWith(positiveSign)) 1322if (value.Slice(index).StartsWith(decimalSeparator)) 1385if (!negSign.IsEmpty && value.Slice(index).StartsWith(negSign)) 1395else if (!posSign.IsEmpty && value.Slice(index).StartsWith(posSign)) 1643ReadOnlySpan<TChar> afterSign = valueTrim.Slice(positiveSign.Length); 1666ReadOnlySpan<TChar> afterSign = valueTrim.Slice(negativeSign.Length); 1677ReadOnlySpan<TChar> afterHyphen = valueTrim.Slice(1);

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);

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

1267searchSpace = searchSpace.Slice(index + matchLength); 1579remaining = remaining.Slice(idx + stride); 1641text = text.Slice(idx + stride); 1669remaining = remaining.Slice(idx + stride); 2145Vector512<ushort> vector2 = Vector512.Create(remaining.Slice(Vector512<ushort>.Count)); 2174remaining = remaining.Slice(Vector512<ushort>.Count*2); 2180remaining = remaining.Slice(Vector512<ushort>.Count*2); 2202remaining = remaining.Slice(Vector512<ushort>.Count); 2209Vector512<ushort> vector = Vector512.Create(sourceSpanUInt16.Slice(sourceSpanUInt16.Length - Vector512<ushort>.Count)); 2240Vector256<ushort> vector2 = Vector256.Create(remaining.Slice(Vector256<ushort>.Count)); 2269remaining = remaining.Slice(Vector256<ushort>.Count*2); 2275remaining = remaining.Slice(Vector256<ushort>.Count*2); 2297remaining = remaining.Slice(Vector256<ushort>.Count); 2304Vector256<ushort> vector = Vector256.Create(sourceSpanUInt16.Slice(sourceSpanUInt16.Length - Vector256<ushort>.Count)); 2335Vector128<ushort> vector2 = Vector128.Create(remaining.Slice(Vector128<ushort>.Count)); 2364remaining = remaining.Slice(Vector128<ushort>.Count*2); 2370remaining = remaining.Slice(Vector128<ushort>.Count*2); 2392remaining = remaining.Slice(Vector128<ushort>.Count); 2399Vector128<ushort> vector = Vector128.Create(sourceSpanUInt16.Slice(sourceSpanUInt16.Length - Vector128<ushort>.Count)); 2439source = source.Slice(index + separator.Length);

404Ascii.FromUtf16(chars.Slice(idx), bytes.Slice(idx), out int charsConsumed); 414chars = chars.Slice(numElementsToConvert); 693Ascii.ToUtf16(bytes.Slice(idx), chars.Slice(idx), out int bytesConsumed); 702bytes = bytes.Slice(numElementsToConvert);

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

235chars: new ReadOnlySpan<char>(pCharsOriginal, originalCharCount).Slice(charsConsumedSoFar), 264ReadOnlySpan<char> chars = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar); 267chars = chars.Slice(charsConsumedJustNow); 283chars = chars.Slice(charsConsumedJustNow); 357chars = chars.Slice(charsConsumedThisIteration); 380chars = chars.Slice(charsConsumedThisIteration); 499chars: new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar), 532ReadOnlySpan<char> chars = new ReadOnlySpan<char>(pOriginalChars, originalCharCount).Slice(charsConsumedSoFar); 537chars = chars.Slice(charsConsumedJustNow); // whether or not the drain finished, we may have made some progress 556chars = chars.Slice(charsConsumedJustNow); 640chars = chars.Slice(charsConsumedThisIteration); 662chars = chars.Slice(charsConsumedThisIteration); 829bytes: new ReadOnlySpan<byte>(pBytesOriginal, originalByteCount).Slice(bytesConsumedSoFar), 858ReadOnlySpan<byte> bytes = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar); 866bytes = bytes.Slice(bytesConsumedJustNow); 883bytes = bytes.Slice(bytesConsumedJustNow); 953bytes = bytes.Slice(bytesConsumedThisIteration); 976bytes = bytes.Slice(bytesConsumedThisIteration); 1095bytes: new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar), 1134ReadOnlySpan<byte> bytes = new ReadOnlySpan<byte>(pOriginalBytes, originalByteCount).Slice(bytesConsumedSoFar); 1143bytes = bytes.Slice(bytesConsumedJustNow); 1159bytes = bytes.Slice(bytesConsumedJustNow); 1244bytes = bytes.Slice(bytesConsumedThisIteration); 1262bytes = bytes.Slice(bytesConsumedThisIteration);

672return DecodeFromUtf8(source.Slice(index), out value, out bytesConsumed); 718source = 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);

2171remainingChunk = 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);

1131result = BinaryPrimitives.ReadUInt128BigEndian(source.Slice(source.Length - Size));

318result = BinaryPrimitives.ReadUInt16BigEndian(source.Slice(source.Length - sizeof(ushort)));

365result = BinaryPrimitives.ReadUInt32BigEndian(source.Slice(source.Length - sizeof(uint)));

372result = BinaryPrimitives.ReadUInt64BigEndian(source.Slice(source.Length - sizeof(ulong)));

373result = BinaryPrimitives.ReadUIntPtrBigEndian(source.Slice(source.Length - sizeof(nuint_t)));

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();

259ReadOnlySpan<char> slice = inputSpan.Slice(pos); 275slice = slice.Slice(iteration); 293slice = slice.Slice(iteration1); 311slice = slice.Slice(iteration2); 329slice = slice.Slice(iteration3); 347slice = slice.Slice(iteration4); 360slice = inputSpan.Slice(pos); 369slice = slice.Slice(iteration5); 387slice = inputSpan.Slice(pos);

263buffer = buffer.Slice(size);

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

78_idHigh = BinaryPrimitives.ReadInt64LittleEndian(source.Slice(8));

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))

359int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString__x_OrdinalIgnoreCase); 379ReadOnlySpan<char> slice = inputSpan.Slice(pos); 402slice = inputSpan.Slice(pos); 417slice = inputSpan.Slice(pos); 492int i = inputSpan.Slice(pos).IndexOfAny('X', 'x'); 513ReadOnlySpan<char> slice = inputSpan.Slice(pos); 517slice = inputSpan.Slice(pos); 537slice = inputSpan.Slice(pos); 561slice = inputSpan.Slice(pos); 576slice = inputSpan.Slice(pos); 665ReadOnlySpan<char> slice = inputSpan.Slice(pos); 688slice = slice.Slice(iteration); 707slice = inputSpan.Slice(pos); 730slice = inputSpan.Slice(pos); 742slice = slice.Slice(iteration1); 758slice = inputSpan.Slice(pos); 837int i = inputSpan.Slice(pos).IndexOfAnyExcept('['); 863ReadOnlySpan<char> slice = inputSpan.Slice(pos); 887slice = inputSpan.Slice(pos); 903slice = slice.Slice(iteration); 917slice = inputSpan.Slice(pos); 939slice = inputSpan.Slice(pos); 960slice = slice.Slice(iteration1); 976slice = inputSpan.Slice(pos); 994slice = slice.Slice(iteration2); 1016slice = inputSpan.Slice(pos); 1042slice = slice.Slice(1); 1127int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_C94AE607B1711C3F90CF8B8C224548ED74A865FE986797F62276464CE6F9271D); 1149ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1161slice = inputSpan.Slice(pos); 1178slice = slice.Slice(iteration); 1195slice = inputSpan.Slice(pos); 1212slice = slice.Slice(iteration1); 1306int i = inputSpan.Slice(pos).IndexOfAnyExcept(' '); 1333ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1353slice = slice.Slice(iteration); 1370slice = inputSpan.Slice(pos); 1385slice = slice.Slice(iteration1); 1408slice = inputSpan.Slice(pos); 1423slice = inputSpan.Slice(pos); 1439slice = slice.Slice(iteration2); 1455slice = inputSpan.Slice(pos); 1471slice = slice.Slice(iteration3); 1486int iteration4 = slice.Slice(1).IndexOf(';'); 1497slice = slice.Slice(iteration4); 1510slice = inputSpan.Slice(pos); 1526slice = slice.Slice(iteration5); 1542slice = inputSpan.Slice(pos); 1558slice = slice.Slice(iteration6); 1651int i = inputSpan.Slice(pos).IndexOfAnyExcept('['); 1675ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1695slice = slice.Slice(iteration); 1712slice = inputSpan.Slice(pos); 1731slice = slice.Slice(iteration1); 1754slice = inputSpan.Slice(pos); 1856int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_A33692426CD23EBB54EC2CE470CB74EA3BB2120AA9FB6C85181C764DD117847E); 1877ReadOnlySpan<char> slice = inputSpan.Slice(pos); 1889slice = inputSpan.Slice(pos); 1900slice = slice.Slice(iteration); 1994int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF); 2016ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2028slice = inputSpan.Slice(pos); 2045slice = slice.Slice(iteration); 2062slice = inputSpan.Slice(pos); 2073slice = slice.Slice(iteration1); 2167int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF); 2188ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2200slice = inputSpan.Slice(pos); 2217slice = slice.Slice(iteration); 2311int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_49E5939642BED022FF4CCC68711C353694EC5E15398AE4B384C29A17BD819BDF); 2332ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2344slice = inputSpan.Slice(pos); 2361slice = slice.Slice(iteration); 2455int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_24E3F0A96FA8DE99FB25D242D87DAC774B6CA6628023D99447766181AE8B5C1F); 2476ReadOnlySpan<char> slice = inputSpan.Slice(pos); 2488slice = inputSpan.Slice(pos); 2505slice = slice.Slice(iteration);

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));

686ReadOnlySpan<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();

533segment = segment.Slice(1); 540segment = segment.Slice(sizeof(ushort));

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;

318var remainder = value.Slice(index);

429intDigits = intDigits.Slice(leadingDigits.Length); 436intDigits = intDigits.Slice(PowersOf1e9.MaxPartialDigits); 1062while (bits.Length < powOfTen.Length + omittedLength || BigIntegerCalculator.Compare(bits.Slice(omittedLength), powOfTen) < 0) 1076BigIntegerCalculator.Divide(bits.Slice(omittedLength), powOfTen, upper, lower.Slice(omittedLength));

348int offset = value.Slice(1).IndexOfAnyExcept((byte)0); 349value = value.Slice(offset < 0 ? byteCount : offset + 1); 420value.Slice(unalignedBytes).CopyTo(limbBytes); 2898bits.Slice(digitShift).CopyTo(zd); 5485bits.Slice(digitShift).CopyTo(zd);

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

460Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 528Debug.Assert(CompareActual(left.Slice(right.Length), right) < 0); 543BurnikelZieglerD3n2n(left.Slice(right.Length), left.Slice(halfN, halfN), right, quotient.Slice(halfN), r1); 562ReadOnlySpan<nuint> a1 = left12.Slice(n); 563ReadOnlySpan<nuint> b1 = right.Slice(n);

84left = left.Slice(k);

110ReadOnlySpan<nuint> valueHigh = value.Slice(n); 314ReadOnlySpan<nuint> left2 = left.Slice(n + n); 317ReadOnlySpan<nuint> right1 = right.Slice(n); 431ReadOnlySpan<nuint> leftHigh = left.Slice(n); 435ReadOnlySpan<nuint> rightHigh = right.Slice(n); 493ReadOnlySpan<nuint> leftHigh = left.Slice(n); 569v1 = value.Slice(n); 575v2 = value.Slice(n + n);

22Debug.Assert(left.Length <= right.Length || left.Slice(right.Length).ContainsAnyExcept(0u)); 23Debug.Assert(left.Length >= right.Length || right.Slice(left.Length).ContainsAnyExcept(0u)); 47if (ActualLength(right.Slice(left.Length)) > 0) 56if (ActualLength(left.Slice(right.Length)) > 0)

1998if (text.Slice(closeBracket + 1).IsWhiteSpace(out trailingWhiteLength))

62effectiveSource = notNull.Slice(1);

98signatureField = signatureField.Slice(1);

15return span.Slice(1).ToArray(); 45span.Slice(1).CopyTo(destination); 88integer = integer.Slice(newStart);

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

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

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

137y = publicKeyBytes.Slice(1 + key.PrivateKey.Length).ToArray(); 211Y = publicKeyBytes.Slice(1 + fieldWidth).ToArray(), 308primeValue = primeValue.Slice(1); 430curve.G.Y = baseSpan.Slice(1 + primeOrPoly.Length).ToArray();

97s = s.Slice(1);

26return 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);

1784afterFirstDot = match.Slice(firstDot + 1); 1806if (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); 414data = data.Slice(idx); 430data = data.Slice(8);

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);

108ReadOnlySpan<char> slice = inputSpan.Slice(pos); 124slice = slice.Slice(iteration); 132slice = slice.Slice(1); 150slice = slice.Slice(iteration1); 164slice = slice.Slice(iteration2); 179slice = inputSpan.Slice(pos);

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)))

316leftLast = leftFractional.Slice(-diff); 319rightMiddle = rightIntegral.Slice(rightOffset); 335leftMiddle = leftIntegral.Slice(leftOffset); 339rightLast = rightFractional.Slice(diff); 377span = span.Slice(1); 398span = span.Slice(i + 1); 415if (!Utf8Parser.TryParse(span.Slice(i + 1), out exp, out _)) 439frac = 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)) 1022ReadOnlySpan<byte> remaining = localBuffer.Slice(_consumed); 1169ReadOnlySpan<byte> span = _buffer.Slice(_consumed); 1241if (!TryGetNumber(_buffer.Slice(_consumed), out int consumed)) 1319ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2351ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2358return SkipSingleLineComment(localBuffer.Slice(1), out _); 2362return SkipMultiLineComment(localBuffer.Slice(1), out _); 2456localBuffer = localBuffer.Slice(idx + 1); 2486int foundIdx = localBuffer.Slice(idx).IndexOf(JsonConstants.Slash); 2528ReadOnlySpan<byte> localBuffer = _buffer.Slice(_consumed + 1); 2535return ConsumeSingleLineComment(localBuffer.Slice(1), _consumed); 2539return 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);

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

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

137ThrowHelper.ThrowArgumentException_InvalidUTF8(value.Slice(encoderBytesWritten)); 160value = value.Slice(indexOfFirstByteToEscape); 190value = value.Slice(indexOfFirstByteToEscape); 284value = value.Slice(indexOfFirstByteToEscape); 314value = 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);

153chars = chars.Slice(i + 1); 449foreach (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);

112int i = inputSpan.Slice(pos).IndexOfAny(Utilities.s_indexOfString_AC244FE541E52CFD90CCD7AB13997D32F9D5031F007841348B9EE5A65488D64E); 132ReadOnlySpan<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);