platform.assumeNotConscrypt()
    platform.assumeNotBouncyCastle()

    val reversed = ConnectionSpec.COMPATIBLE_TLS.cipherSuites!!.reversed()
    val client =
      makeClient(
        ConnectionSpec.COMPATIBLE_TLS,
        TlsVersion.TLS_1_2,
        reversed,
      )

    makeRequest(client)

    val expectedConnectionCipherSuites = expectedConnectionCipherSuites(client)

		d[i].b = i
	}
}

// InOrder checks if a-equal elements were not reordered.
// If reversed is true, expect reverse ordering.
func (d intPairs) inOrder(reversed bool) bool {
	lastA, lastB := -1, 0
	for i := 0; i < len(d); i++ {
		if lastA != d[i].a {
			lastA = d[i].a
			lastB = d[i].b
			continue
		}
		if !reversed {
			if d[i].b <= lastB {
				return false
			}
		} else {
			if d[i].b >= lastB {

    }

    @Override
    void assertSampleSpecificOutcome(String dsl) {
        workerExecutorSample(dsl).file("sources").listFiles().each { File sourceFile ->
            result.assertOutputContains("Reversed ${sourceFile.size()} bytes from ${sourceFile.name}")
        }
    }

        !container.hasMatchingConflict(val -> val == 2)
        container.hasMatchingConflict(val -> val == 3)
        container.popConflict().toString() == "a,b:3,4"
    }

    def "contains replacement conflict reversed"() {
        container.newElement("b", [3, 4], null)
        container.newElement("a", [1, 2], "b")
        expect:
        container.size == 1
        container.popConflict().toString() == "b,a:3,4"
    }

import com.google.common.collect.ImmutableMap;
import java.util.Deque;

/** Parser for a map of reversed domain names stored as a serialized radix tree. */
@GwtCompatible
final class TrieParser {

  private static final Joiner DIRECT_JOINER = Joiner.on("");

  /**
   * Parses a serialized trie representation of a map of reversed public suffixes into an immutable

                parameters.destinationDir = outputDir
            }
        }
    }
}
// end::task-implementation[]

tasks.register('reverseFiles', ReverseFiles) {
    outputDir = layout.buildDirectory.dir("reversed")
    source("sources")

    }

    void assertReversedFileIsPresentAndCorrect(String dsl, String author) {
        def reversedFile = workerExecutorSample(dsl).file("build/reversed/${author}.txt")
        assert reversedFile.exists()
        assert reversedFile.readLines() == workerExecutorSample(dsl).file("sources/${author}.txt").readLines().collect { it.reverse() }
    }

            if (change.changeType == ChangeType.REMOVED) {
                targetFile.delete()
            } else {
                targetFile.writeText(change.file.readText().reversed())
            }
        }
        // end::process-changed-inputs[]
    }
}

            // may change so the installation path breaks ties to keep sorted output consistent
            // between runs.
            .thenComparing(JvmInstallationMetadata::getJavaHome)
            .reversed()
            .compare(o1, o2);
    }

    boolean isCurrentJvm(JvmInstallationMetadata metadata) {
        return metadata.getJavaHome().toFile().equals(currentJavaHome);
    }

                }
                dfs(superClassSymbol)
                check(stack.removeLast().second == superClassSymbol)
            }
        }

        dfs(baseSymbol)
        return result?.reversed()
    }