fun foo(bar: String) {}
                }
                operator fun Source.invoke(arg: String) {}
            """,
            v2 = """
                class Source(some: String?) {
                    fun foo(bar: String?) {}
                }
                operator fun Source.invoke(arg: String?) {}
            """
        ) {
            assertHasNoError()

      val bit = 1 shl INITIAL_WINDOW_SIZE
      return if (bit and set != 0) values[INITIAL_WINDOW_SIZE] else DEFAULT_INITIAL_WINDOW_SIZE
    }

  fun clear() {
    set = 0
    values.fill(0)
  }

  operator fun set(
    id: Int,
    value: Int,
  ): Settings {
    if (id < 0 || id >= values.size) {
      return this // Discard unknown settings.
    }

    val bit = 1 shl id
    set = set or bit

 * limitations under the License.
 */

package gradlebuild.binarycompatibility.filters

import japicmp.filter.BehaviorFilter
import javassist.CtBehavior

/**
 * Kotlin 2.2 produces bridge methods for invoke operator functions compiled as JVM default methods.
 */
class KotlinInvokeDefaultBridgeFilter implements BehaviorFilter {
    @Override
    boolean matches(CtBehavior ctBehavior) {

		code:       "LexerInvalidLiteral",
		message:    "The SQL expression contains an invalid operator.",
		statusCode: 400,
		cause:      err,
	}
}

func errLexerInvalidIONLiteral(err error) *s3Error {
	return &s3Error{
		code:       "LexerInvalidIONLiteral",
		message:    "The SQL expression contains an invalid operator.",
		statusCode: 400,
		cause:      err,
	}
}

import org.gradle.process.ExecOperations
import java.io.ByteArrayOutputStream
import java.io.File


/**
 * `dir / "sub"` is the same as `dir.resolve("sub")`.
 *
 * @see [File.resolve]
 */
operator fun File.div(child: String): File =
    resolve(child)


fun ExecOperations.execAndGetStdout(workingDir: File, ignoreExitValue: Boolean, vararg args: String): String {
    val out = ByteArrayOutputStream()
    exec {

  val defaultAddress: InetSocketAddress?,
) : DelegatingSocketFactory(getDefault()) {
  private val hostMapping = mutableMapOf<InetAddress, InetSocketAddress>()

  /** Sets the [real] address for [requested].  */
  operator fun set(
    requested: InetAddress,
    real: InetSocketAddress,
  ) {
    hostMapping[requested] = real
  }

  override fun createSocket(): Socket =
    object : Socket() {
      override fun connect(

        def infixChanged = oldIsInfix != newIsInfix

        if (operatorChanged || infixChanged) {
            List<String> changes = []
            if (operatorChanged) {
                changes.add(modifierChangeDetail("operator", newIsOperator))
            }
            if (infixChanged) {
                changes.add(modifierChangeDetail("infix", newIsInfix))
            }

  private val requestedHosts: MutableList<String> = Collections.synchronizedList(mutableListOf())
  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

  /** Sets the results for `hostname`.  */
  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses
    return this
  }

  /** Clears the results for `hostname`.  */

    val entryPoints: MutableSet<ClassDetails> = linkedSetOf()

    val shadowPackagePrefix =
        shadowPackage.takeIf(String::isNotEmpty)
            ?.let { it.replace('.', '/') + "/" }
            ?: ""

    operator fun get(className: String) =
        classes.computeIfAbsent(className) {
            val outputClassName = if (unshadedPackages.matches(className)) className else shadowPackagePrefix + className

  virtual absl::Status RemoveFunction(const string& func) = 0;

 private:
  const AbstractContextKind kind_;
};

namespace internal {
struct AbstractContextDeleter {
  void operator()(AbstractContext* p) const {
    if (p != nullptr) {
      p->Release();
    }
  }
};
}  // namespace internal

using AbstractContextPtr =