// If fn is declared as vararg, we have to pass the vararg arguments on the stack.
	// (Because ios decided not to adhere to the standard arm64 calling convention, sigh...)
	// The only libSystem calls we support that are vararg are open, fcntl, and ioctl,
	// which are all of the form fn(x, y, ...). So we just need to put the 3rd arg
	// on the stack as well.

        this.cipherSuites = null
      }

    fun cipherSuites(vararg cipherSuites: CipherSuite): Builder =
      apply {
        require(tls) { "no cipher suites for cleartext connections" }
        val strings = cipherSuites.map { it.javaName }.toTypedArray()
        return cipherSuites(*strings)
      }

    fun cipherSuites(vararg cipherSuites: String) =
      apply {

 * limitations under the License.
 */
package okhttp3

import okio.Buffer
import okio.Path
import okio.Path.Companion.toPath

val okHttpRoot: Path
  get() = getEnv("OKHTTP_ROOT")!!.toPath()

fun String(vararg codePoints: Int): String {
  val buffer = Buffer()
  for (codePoint in codePoints) {
    buffer.writeUtf8CodePoint(codePoint)
  }
  return buffer.readUtf8()

 * See [Configuration.extendsFrom].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().extendsFrom(superConfigs)"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.extendsFrom(vararg superConfigs: Configuration) =
    get().extendsFrom(*superConfigs)


/**
 * See [Configuration.isTransitive].
 */

import org.gradle.api.file.CopySpec

import java.io.FilterReader


/**
 * Adds a content filter to be used during the copy.
 *
 * @see [CopySpec.filter]
 */
inline fun <reified T : FilterReader> CopySpec.filter(vararg properties: Pair<String, Any?>) =
    filter(mapOf(*properties), T::class.java)


/**
 * Adds a content filter to be used during the copy.
 *
 * @see [CopySpec.filter]
 */

                  <T>: kotlin.Int
                  $receiver: CALL 'public final fun listOf <T> (vararg elements: T of kotlin.collections.listOf): kotlin.collections.List<T of kotlin.collections.listOf> declared in kotlin.collections' type=kotlin.collections.List<kotlin.Int> origin=null
                    <T>: kotlin.Int
                    elements: VARARG type=kotlin.Array<out kotlin.Int> varargElementType=kotlin.Int

 * ```
 *
 * @param T type of the filter to add
 * @param properties map of filter properties
 * @return this
 */
inline fun <reified T : FilterReader> ContentFilterable.filter(vararg properties: Pair<String, Any?>) =
    if (properties.isEmpty()) filter(T::class.java)
    else filter(mapOf(*properties), T::class.java)


/**
 * Adds a content filter to be used during the copy.

    override fun file(path: Any): File =
        fileOperations.file(path)

    override fun file(path: Any, validation: PathValidation): File =
        fileOperations.file(path, validation)

    override fun files(vararg paths: Any): ConfigurableFileCollection =
        fileOperations.configurableFiles(*paths)

    override fun files(paths: Any, configuration: Action<ConfigurableFileCollection>): ConfigurableFileCollection =

    final Kind kind;

    ParameterMatchEntry(Type type, Kind kind) {
        this.type = type;
        this.kind = kind;
    }

    enum Kind {
        RECEIVER_AS_CLASS, RECEIVER, PARAMETER, VARARG
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof ParameterMatchEntry)) {
            return false;
        }

internal
fun excludeMapFor(group: String?, module: String?): Map<String, String> =
    mapOfNonNullValuesOf(
        "group" to group,
        "module" to module
    )


internal
fun mapOfNonNullValuesOf(vararg entries: Pair<String, String?>): Map<String, String> =
    mutableMapOf<String, String>().apply {
        for ((k, v) in entries) {
            if (v != null) {
                put(k, v)
            }
        }