int padding = (4 - ((wideBytes.length + 2) % 4)) % 4;
            for (int i = 0; i < padding; i++) {
                buf.enc_ndr_small(0);
            }
        }
    }

    /**
     * Decodes a wide string pointer from NDR format.
     *
     * @param buf the NDR buffer
     * @return the decoded string (or null if NULL pointer)
     * @throws NdrException if decoding fails
     */

                u = u.substring(idx + 1);
            } else {
                u = StringUtil.EMPTY;
            }
        }
        return u;
    }

    /**
     * Decodes a URL as a name using appropriate character encoding.
     * Handles encoding detection from parent URLs and configuration settings.
     *
     * @param url the URL to decode

package cmd

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *healingTracker) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()

        assertEquals(0, notifyInfo.getAction());
        assertNull(notifyInfo.getFileName());
        assertEquals(0, notifyInfo.getNextEntryOffset());
    }

    @Test
    @DisplayName("Test constructor with buffer decodes correctly")
    void testConstructorWithBuffer() throws IOException {
        // Create test buffer with notification data

// out of HTTP "chunked" format before returning it.
// The s3ChunkedReader returns io.EOF when the final 0-length chunk is read.
//
// NewChunkedReader is not needed by normal applications. The http package
// automatically decodes chunking when reading response bodies.
func newSignV4ChunkedReader(req *http.Request, trailer bool) (io.ReadCloser, APIErrorCode) {
	cred, seedSignature, region, seedDate, errCode := calculateSeedSignature(req, trailer)

@J2ktIncompatible
@GwtIncompatible
public abstract class ByteSource {

  /** Constructor for use by subclasses. */
  protected ByteSource() {}

  /**
   * Returns a {@link CharSource} view of this byte source that decodes bytes read from this source
   * as characters using the given {@link Charset}.
   *
   * <p>If {@link CharSource#asByteSource} is called on the returned source with the same charset,

package cmd

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *BucketMetadata) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()

            }
            return null;
        }
        return permission;
    }

    /**
     * Decodes a search role format string back to a permission string.
     * Reverses the encoding process to restore original permission format.
     *
     * @param value the encoded permission string to decode

            }
            return null;
        } catch (final Exception e) {
            throw new CrawlingAccessException("Failed to parse " + url, e);
        }
    }

    /**
     * Decodes a similar document hash from its compressed and encoded form.
     * Reverses the encoding process applied by encodeSimilarDocHash.
     *
     * @param hash the encoded hash string to decode

    }
  }

  companion object {
    private val PEM_REGEX = Regex("""-----BEGIN ([!-,.-~ ]*)-----([^-]*)-----END \1-----""")

    /**
     * Decodes a multiline string that contains both a [certificate][certificatePem] and a
     * [private key][privateKeyPkcs8Pem], both [PEM-encoded][rfc_7468]. A typical input string looks
     * like this:
     *
     * ```