}
    return comparator;
  }

  @Override
  public boolean containsKey(Object key) {
    try {
      return delegate.containsKey(checkValid(key));
    } catch (NullPointerException | ClassCastException e) {
      return false;
    }
  }

  @Override
  public boolean containsValue(Object value) {
    return delegate.containsValue(value);
  }

  @Override

            }
            return this.handle;
        }
        return this.handle.acquire();
    }

    /**
     * Converts an SmbException to an IOException
     *
     * @param se the SmbException to convert
     * @return an IOException wrapping the SmbException
     */
    protected static IOException seToIoe(final SmbException se) {

        // TCP doesn't need real memory registration
        return new TcpMemoryRegion(buffer, access);
    }

    @Override
    public String getProviderName() {
        return "TCP Fallback";
    }

    @Override
    public int getMaxMessageSize() {
        return 65536; // 64KB for TCP
    }

    @Override
    public void shutdown() {

  }

  @Override public ServerSocket createServerSocket() throws IOException {
    return new UnixDomainServerSocket();
  }

  @Override public ServerSocket createServerSocket(int port) throws IOException {
    return createServerSocket();
  }

  @Override public ServerSocket createServerSocket(int port, int backlog) throws IOException {
    return createServerSocket();
  }

  @Override public ServerSocket createServerSocket(

	vc, err := sys.Get(bucket)
	if err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	return vc.PrefixEnabled(prefix)
}

// Suspended suspended versioning?
func (sys *BucketVersioningSys) Suspended(bucket string) bool {
	vc, err := sys.Get(bucket)
	if err != nil {
		logger.CriticalIf(GlobalContext, err)
	}
	return vc.Suspended()
}

// PrefixSuspended returns true if the given prefix matches an excluded prefix

    static abstract class BaseCreds implements SmbRenewableCredentials {
        @Override
        public CredentialsInternal clone() {
            // For testing purposes, return this instance (allowed by return type)
            return this;
        }

        @Override
        public SSPContext createContext(CIFSContext tc, String targetDomain, String host, byte[] initialToken, boolean doSigning)

            return this;
        }

        public Builder withTopDirectory(@Nonnull Path topDirectory) {
            this.topDirectory = requireNonNull(topDirectory, "topDirectory");
            return this;
        }

        public Builder withRootDirectory(@Nullable Path rootDirectory) {
            this.rootDirectory = rootDirectory;
            return this;
        }

	if err != nil {
		return
	}
	err = en.WriteInt(z.ScanMode)
	if err != nil {
		err = msgp.WrapError(err, "ScanMode")
		return
	}
	// write "c"
	err = en.Append(0xa1, 0x63)
	if err != nil {
		return
	}
	if z.Cache == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Cache.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Cache")
			return
		}
	}

    return ItemOut(name=item.name, value=item.value, dep=dep)


@app.get("/sync/dict-no-response-model")
def sync_dict_no_response_model():
    return {"name": "foo", "value": 123}


@app.get("/sync/dict-with-response-model", response_model=ItemOut)
def sync_dict_with_response_model(
    dep: Annotated[int, Depends(dep_b)],
):
    return {"name": "foo", "value": 123, "dep": dep}

        return this.maxMpxCount;
    }

    @Override
    public String getNativeLanman() {
        return this.nativeLanMan;
    }

    @Override
    public String getNativeOs() {
        return this.nativeOs;
    }

    @Override
    public int getVcNumber() {
        return this.vcNumber;
    }

    @Override
    public int getCapabilities() {
        return this.capabilities;