void putLongLittleEndian(byte[] array, int offset, long value);
  }

  /**
   * The only reference to Unsafe is in this nested class. We set things up so that if
   * Unsafe.theUnsafe is inaccessible, the attempt to load the nested class fails, and the outer
   * class's static initializer can fall back on a non-Unsafe version.
   */
  @SuppressWarnings({"SunApi", "removal"}) // b/345822163

    void putLongLittleEndian(byte[] array, int offset, long value);
  }

  /**
   * The only reference to Unsafe is in this nested class. We set things up so that if
   * Unsafe.theUnsafe is inaccessible, the attempt to load the nested class fails, and the outer
   * class's static initializer can fall back on a non-Unsafe version.
   */
  @SuppressWarnings({"SunApi", "removal"}) // b/345822163

    "actions",
    "enabled",
    "timeout",
    "onlyIfSpec",
    "logger",
)


internal
fun AccessibleObject.makeAccessible() {
    @Suppress("deprecation")
    if (!isAccessible) isAccessible = true
}


private
object Workarounds {

    private
    val ignoredBeanFields = arrayOf(
        // TODO:configuration-cache remove once fixed

            val typeMethod = builtinTypes::class.java.methods.singleOrNull {
                it.name == "get" + builtInTypeName.capitalizeAsciiOnly()
            }!!
            typeMethod.isAccessible = true
            return typeMethod.invoke(builtinTypes) as KaType
        }
    }

    object Directives : SimpleDirectivesContainer() {
        val BUILTIN_TYPE_NAME by stringDirective("name of built in type")

    allMethods().firstAccessibleMatchingMethodOrNull(predicate)


internal
fun Iterable<Method>.firstAccessibleMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =
    find(predicate)?.apply { isAccessible = true }


internal
fun Class<*>.firstMatchingMethodOrNull(predicate: Method.() -> Boolean): Method? =
    allMethods().find(predicate)


internal
fun Class<*>.allMethods() =

type KMSLogger struct{}

// LogOnceIf is the implementation of LogOnceIf, accessible using the Logger interface
func (l KMSLogger) LogOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, "kms", err, id, errKind...)
}

// LogIf is the implementation of LogIf, accessible using the Logger interface
func (l KMSLogger) LogIf(ctx context.Context, err error, errKind ...interface{}) {

object JavaRecordEncoding : Encoding {
    override suspend fun WriteContext.encode(value: Any) {
        val clazz = value::class.java
        writeClass(clazz)
        for (field in clazz.relevantFields) {
            field.isAccessible = true
            val fieldName = field.name
            val fieldValue = field.get(value)
            unsupportedFieldTypeFor(field)?.let {
                reportUnsupportedFieldType(it, "serialize", fieldName, fieldValue)

import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KProperty
import kotlin.reflect.KVisibility
import kotlin.reflect.full.*
import kotlin.reflect.jvm.isAccessible

public class DebugSymbolRenderer(
    public val renderExtra: Boolean = false,
    public val renderTypeByProperties: Boolean = false,
    public val renderExpandedTypes: Boolean = false,
) {

        dynamicPropertyExpression << [
            'gradleProp',
            'ext.gradleProp'
        ]
    }

    @Issue("https://github.com/gradle/gradle/issues/19793")
    def "gradle properties must be accessible from task in #build"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        build.setup(this)

        when:
        configurationCacheRun build.task()

        then:

It will have **auto-reload disabled** by default.

It will listen on the IP address `0.0.0.0`, which means all the available IP addresses, this way it will be publicly accessible to anyone that can communicate with the machine. This is how you would normally run it in production, for example, in a container.