* unsigned.
   *
   * <p><b>Java 8+ users:</b> use {@link Long#toUnsignedString(long, int)} instead.
   *
   * @param x the value to convert to a string.
   * @param radix the radix to use while working with {@code x}
   * @throws IllegalArgumentException if {@code radix} is not between {@link Character#MIN_RADIX}
   *     and {@link Character#MAX_RADIX}.
   */

	ep, err := unescapeGeneric(p, escapeFn)
	if err != nil {
		return p
	}
	return ep
}

func updateReqContext(ctx context.Context, objects ...ObjectV) context.Context {
	req := logger.GetReqInfo(ctx)
	if req != nil {
		req.Lock()
		defer req.Unlock()
		req.Objects = make([]logger.ObjectVersion, 0, len(objects))
		for _, ov := range objects {

        if (StringUtil.isNotBlank(childUrl)) {
            final DuplicateHostHelper duplicateHostHelper = ComponentUtil.getDuplicateHostHelper();
            final String url = duplicateHostHelper.convert(childUrl);
            super.storeChildUrl(url, parentUrl, weight, depth);
        }
    }

    /**
     * Retrieves the appropriate crawler client for the given URL based on configured rules.

import org.jspecify.annotations.Nullable;

/**
 * An {@link Escaper} that converts literal text into a format safe for inclusion in a particular
 * context (such as an XML document). Typically (but not always), the inverse process of
 * "unescaping" the text is performed automatically by the relevant parser.
 *
 * <p>For example, an XML escaper would convert the literal string {@code "Foo<Bar>"} into {@code

///

## Password hashing { #password-hashing }

"Hashing" means converting some content (a password in this case) into a sequence of bytes (just a string) that looks like gibberish.

Whenever you pass exactly the same content (exactly the same password) you get exactly the same gibberish.

But you cannot convert from the gibberish back to the password.

### Why use password hashing { #why-use-password-hashing }

@DisplayName("Type3Message Tests")
class Type3MessageTest {

    @Mock
    private CIFSContext mockContext;

    @BeforeEach
    void setUp() {
        // Basic setup for mock context if needed
    }

    /**
     * Helper method to create properly configured mock context
     */
    private CIFSContext createMockContext() {
        CIFSContext mockCtx = mock(CIFSContext.class);
        Configuration mockConfig = mock(Configuration.class);

// nearest block edge where 0 <= n < blockSize.
func blockPadding(offset int64) (n int64) {
	return -offset & (blockSize - 1)
}

var zeroBlock block

type block [blockSize]byte

// Convert block to any number of formats.
func (b *block) toV7() *headerV7       { return (*headerV7)(b) }
func (b *block) toGNU() *headerGNU     { return (*headerGNU)(b) }
func (b *block) toSTAR() *headerSTAR   { return (*headerSTAR)(b) }

@Test
public void testDirectoryChangeNotification() throws Exception {
    CIFSContext context = getTestContext();
    context.getConfig().setProperty("jcifs.smb.client.directoryNotificationsEnabled", "true");
    
    SmbFile dir = new SmbFile("smb://server/share/testdir/", context);
    SmbFile testFile = new SmbFile("smb://server/share/testdir/newfile.txt", context);
    
    // Get initial listing (establishes cache)

//// tab | Test

This is a code snippet: `foo`. And this is another code snippet: `bar`. And another one: `baz quux`.

////

//// tab | Info

Content of code snippets should be left as is.

See section `### Content of code snippets` in the general prompt in `scripts/translate.py`.

////

## Quotes { #quotes }

//// tab | Test

	*config = Config(parsedConfig)
	return nil
}

// ToRetention - convert to Retention type.
func (config *Config) ToRetention() Retention {
	r := Retention{
		LockEnabled: config.ObjectLockEnabled == Enabled,
	}
	if config.Rule != nil {
		r.Mode = config.Rule.DefaultRetention.Mode

		t, err := UTCNowNTP()
		if err != nil {
			lockLogIf(context.Background(), err)
			// Do not change any configuration