try (Response response = client.newCall(request).execute()) {
      // Deserialize HTTP response to concrete type.
      ResponseBody body = response.body();
      List<Contributor> contributors = CONTRIBUTORS_JSON_ADAPTER.fromJson(body.source());

      // Sort list by the most contributions.
      Collections.sort(contributors, (c1, c2) -> c2.contributions - c1.contributions);

      // Output list of contributors.

        private
        fun updateReleasedVersionFile(releasedVersionsFile: File, currentReleasedVersion: ReleasedVersion) {
            val releasedVersions = releasedVersionsFile.reader().use {
                Gson().fromJson(it, ReleasedVersions::class.java)
            }

            val newReleasedVersions = updateReleasedVersions(currentReleasedVersion, releasedVersions)

  unit-test:
    name: "${{ matrix.bucket.name }} (Unit Test)"
    permissions:
      contents: read
    runs-on: ubuntu-latest
    needs: build
    strategy:
      matrix:
        bucket: ${{ fromJson(needs.build.outputs.matrix) }}
      fail-fast: false
    steps:
      - name: git clone
        uses: actions/checkout@v4
      - name: setup java
        uses: actions/setup-java@v4
        with:

  build-docs:
    needs:
      - changes
      - langs
    if: ${{ needs.changes.outputs.docs == 'true' }}
    runs-on: ubuntu-latest
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v4

    }

    class TeamCityParallelTests(val numberOfBatches: Int) : ParallelizationMethod()

    companion object {
        fun fromJson(jsonObject: JSONObject): ParallelizationMethod {
            val methodJsonObject = jsonObject.getJSONObject("parallelizationMethod") ?: return None
            return when (methodJsonObject.getString("name")) {

        if (response.statusCode() > 399) {
            throw RuntimeException("Failed to get pull requests: $uri ${response.statusCode()} ${response.body()}")
        }
        return Gson().fromJson(response.body(), klass)
    }

    private
    fun getUserInfo(login: String): GitHubUser {
        val uri = "https://api.github.com/users/$login"
        return invokeGitHubApi(uri, GitHubUser::class.java)

        assertEquals(expectedFirstJson, actualFirstJson)
        assertEquals(expectedSecondJson, actualSecondJson)
    }

    private
    fun loadChangesJson(rawText: String) = Gson().fromJson(rawText, AbstractAcceptedApiChangesMaintenanceTask.AcceptedApiChanges::class.java)

    val parallelizationMethod: ParallelizationMethod
) {
    constructor(jsonObject: JSONObject) : this(
        jsonObject.getJSONArray("subprojects").map { it.toString() },
        ParallelizationMethod.fromJson(jsonObject)
    )

    fun toBuildTypeBucket(gradleSubprojectProvider: GradleSubprojectProvider): SmallSubprojectBucket = SmallSubprojectBucket(
        subprojects.map { gradleSubprojectProvider.getSubprojectByName(it)!! },

        if (!file.exists()) {
            return Collections.emptyList();
        }
        try (FileReader reader = new FileReader(file)) {
            List<UpgradedProperty> upgradedProperties = new Gson().fromJson(reader, new TypeToken<List<UpgradedProperty>>() {}.getType());
            // FIXME There should be no duplicates, yet there are some
            return upgradedProperties.stream()
                .distinct()

            .build()
        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          val gist = gistJsonAdapter.fromJson(response.body!!.source())

          for ((key, value) in gist!!.files!!) {
            println(key)
            println(value.content)
          }
        }
      }