<sha256 value="47dcde8986019314ef78ae7280a94973a21d2ed95075a40a000b42da956429e1" origin="Verified" reason="Artifact is not signed"/>
         </artifact>
      </component>
      <component group="xyz.rogfam" name="littleproxy" version="2.0.5">
         <artifact name="littleproxy-2.0.5.jar">
            <pgp value="CEAB6BCE846FDA635DA5966414D16906D9482A92"/>
         </artifact>
      </component>
   </components>

     */
    data class Script(val source: ProgramSource) : Program()

    /**
     * A [Stage1] program followed by a stage 2 [Script] program.
     */
    data class Staged(val stage1: Stage1, val stage2: Script) : Program()

    /**
     * Any stage 1 program, one of [Buildscript], [Plugins] or [a sequence of the two][Stage1Sequence].
     */
    abstract class Stage1 : Program()

        is Program.Buildscript -> reduceBuildscriptProgram(program)

        is Program.Plugins -> stage1WithPlugins(program)

        is Program.Stage1Sequence -> stage1WithPlugins(program)

        is Program.Script -> reduceScriptProgram(program)

        is Program.Staged -> reduceStagedProgram(program)

        else -> throw IllegalArgumentException("Unsupported `$program'")
    }

        assertProgramOf(
            source,
            Program.Staged(
                Program.Stage1Sequence(
                    Program.PluginManagement(source.fragment(0..15, 17..55)),
                    Program.Buildscript(source.fragment(57..67, 69..102)),
                    Program.Plugins(source.fragment(104..110, 112..141))
                ),
                Program.Script(source.map { text(expectedScript) })
            ),

        val program =
            Program.Staged(
                Program.Stage1Sequence(
                    Program.PluginManagement(fragment("pluginManagement", "...")),
                    null,
                    Program.Plugins(fragment("plugins", "..."))
                ),
                Program.Script(ProgramSource("script.gradle.kts", "..."))
            )

        assertThat(

        ) {

            val program = assertInstanceOf<ExecutableProgram.StagedProgram>(this)
            program.execute(programHost, scriptHost)

            inOrder(programHost) {
                verify(programHost).closeTargetScopeOf(scriptHost)
                verify(programHost).evaluateSecondStageOf(
                    program = program,
                    scriptHost = scriptHost,

     ii) additions to the Program;
  where such changes and/or additions to the Program originate from
  and are Distributed by that particular Contributor. A Contribution
  "originates" from a Contributor if it was added to the Program by
  such Contributor itself or anyone acting on such Contributor's behalf.
  Contributions do not include changes or additions to the Program that
  are not Modified Works.

	return r.pgcounter[pgkey{program, counter}]
}

func (r *Config) HasCounterPrefix(program, prefix string) bool {
	return r.pgcounterprefix[pgkey{program, prefix}]
}

func (r *Config) HasStack(program, stack string) bool {
	return r.pgstack[pgkey{program, stack}]
}

func (r *Config) Rate(program, name string) float64 {
	return r.rate[pgkey{program, name}]
}

         i) changes to the Program, and

         ii) additions to the Program;

where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution 'originates' from
a Contributor if it was added to the Program by such Contributor itself or
anyone acting on such Contributor's behalf. Contributions do not include additions

        )

        assertProgramOf(
            source,
            Program.Staged(
                Program.Stage1Sequence(
                    null,
                    Program.Buildscript(source.fragment(81..91, 93..161)),
                    Program.Plugins(source.fragment(29..35, 37..56))
                ),
                Program.Script(expectedScriptSource)
            )
        )
    }