// it.
func ParseUnverifiedStandardClaims(token []byte, claims *StandardClaims, buf []byte) (*SigningMethodHMAC, error) {
	if bytes.Count(token, []byte(".")) != 2 {
		return nil, jwtgo.ErrSignatureInvalid
	}

	i := bytes.IndexByte(token, '.')
	j := bytes.LastIndexByte(token, '.')

	n, err := base64DecodeBytes(token[:i], buf)
	if err != nil {

        // Padding to align data to 8-byte boundary
        dstIndex += 4;

        // Write durable handle V2 request data (32 bytes total)
        // MS-SMB2 2.2.13.2.4 structure:
        SMBUtil.writeInt4((int) getTimeoutFor100Ns(), dst, dstIndex); // Timeout (4 bytes in 100-ns intervals)
        dstIndex += 4;

        SMBUtil.writeInt4(flags, dst, dstIndex); // Flags (4 bytes)
        dstIndex += 4;

		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

	left, err = msgp.Skip(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after Skip(): %q", len(left), left)
	}
}

func BenchmarkMarshalMsgMetricDescription(b *testing.B) {

		"Total number of bytes failed at least once to replicate in the last hour on a bucket",
		bucketL, targetArnL)
	bucketReplLastHrFailedCountMD = NewGaugeMD(bucketReplLastHrFailedCount,
		"Total number of objects which failed replication in the last hour on a bucket",
		bucketL, targetArnL)
	bucketReplLastMinFailedBytesMD = NewGaugeMD(bucketReplLastMinFailedBytes,

		src      io.Reader
		skipLen  int64
		expected string
	}{
		{bytes.NewBuffer([]byte("")), 0, ""},
		{bytes.NewBuffer([]byte("")), 1, ""},
		{bytes.NewBuffer([]byte("abc")), 0, "abc"},
		{bytes.NewBuffer([]byte("abc")), 1, "bc"},
		{bytes.NewBuffer([]byte("abc")), 2, "c"},
		{bytes.NewBuffer([]byte("abc")), 3, ""},
		{bytes.NewBuffer([]byte("abc")), 4, ""},
	}
	for i, testCase := range testCases {

        // Create buffer with exact decode size
        byte[] tempBuffer = new byte[50];
        original.encode(tempBuffer, 0);

        // Copy only the first 36 bytes (what decode reads)
        byte[] buffer = new byte[36];
        System.arraycopy(tempBuffer, 0, buffer, 0, 36);

        // Decode

		t.Fatal("Key[0] is not using P-256 curve")
	} else if !bytes.Equal(key0.X.Bytes(), []byte{
		0x30, 0xa0, 0x42, 0x4c, 0xd2,
		0x1c, 0x29, 0x44, 0x83, 0x8a, 0x2d, 0x75, 0xc9, 0x2b, 0x37, 0xe7, 0x6e, 0xa2,
		0xd, 0x9f, 0x0, 0x89, 0x3a, 0x3b, 0x4e, 0xee, 0x8a, 0x3c, 0xa, 0xaf, 0xec, 0x3e,
	}) {
		t.Fatalf("Bad key[0].X, got %v", key0.X.Bytes())
	} else if !bytes.Equal(key0.Y.Bytes(), []byte{
		0xe0, 0x4b, 0x65, 0xe9, 0x24,

   * stream. When encoding it is "unflipped" (encoded bytes between 0 and position) and when
   * draining it is flipped (undrained bytes between position and limit).
   */
  private ByteBuffer byteBuffer;

  /** Whether we've finished reading the reader. */
  private boolean endOfInput;

  /** Whether we're copying encoded bytes to the caller's buffer. */
  private boolean draining;

        byte[] buffer = new byte[256];
        Arrays.fill(buffer, (byte) 0xCC); // Fill with pattern to detect unwritten areas

        int written = request.writeBytesWireFormat(buffer, 0);

        // Verify structure according to SMB2 FLUSH specification
        // Structure Size (2 bytes) - should be 24
        assertEquals(24, SMBUtil.readInt2(buffer, 0));

    ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
    byte[] actual = new byte[bytes.length];
    in.readFully(actual);
    assertThat(actual).isEqualTo(bytes);
  }

  public void testNewDataInput_readFullyAndThenSome() {
    ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
    byte[] actual = new byte[bytes.length * 2];
    IllegalStateException ex =