if cmp(x[i], x[i-1]) < 0 {
			return false
		}
	}
	return true
}

// Min returns the minimal value in x. It panics if x is empty.
// For floating-point numbers, Min propagates NaNs (any NaN value in x
// forces the output to be NaN).
func Min[S ~[]E, E cmp.Ordered](x S) E {
	if len(x) < 1 {
		panic("slices.Min: empty list")
	}
	m := x[0]
	for i := 1; i < len(x); i++ {
		m = min(m, x[i])
	}
	return m
}

          <show>package</show>
        </configuration>
      </plugin>
      <!-- Disable "normal" testing, which doesn't work for GWT tests. -->
      <plugin>

class ModuleForcingResolveRuleSpec extends Specification {

    private static ModuleIdentifier mid(String group, String name) {
        DefaultModuleIdentifier.newId(group, name)
    }

    def "forces modules"() {
        given:
        def details = Mock(DependencySubstitutionInternal)

        when:
        new ModuleForcingResolveRule([
            newSelector(mid("org", "module1"), "1.0"),

	if err := tc.syncFunc(ctx, key); err != nil {
		tc.queue.AddRateLimited(key)
		utilruntime.HandleError(fmt.Errorf("Sync %v failed with : %v", key, err))
		return true
	}

	tc.queue.Forget(key)
	return true
}

func (tc *TokenCleaner) syncFunc(ctx context.Context, key string) error {
	logger := klog.FromContext(ctx)
	startTime := time.Now()
	defer func() {

   * return type is plain FilenameFilter. If we made such a change, then the annotation we choose
   * here would have no significance to end users, who would be forced to conform to the signature
   * used in FilenameFilter.)
   */
  @Override
  public boolean accept(File dir, String fileName) {
    return pattern.matcher(fileName).matches();
  }

        ])
        if (appliesBasePlugin) {
            assert output.count("configuring :") == 2
            outputContains("configuring :help")
            // because capturing registered outputs for stale output cleanup forces configuring clean
            outputContains("configuring :clean")
        } else {
            assert output.count("configuring :") == 1
            outputContains("configuring :help")
        }
    }

        succeeds ":b:${language.compileTaskName}", "--debug"

        then:
        executedAndNotSkipped(":b:${language.compileTaskName}")

        when:
        // Remove sealed modifier, forces change to API.
        file("a/src/main/${language.name}/Foo.${language.name}").delete()
        file("a/src/main/${language.name}/Foo.${language.name}") << '''
interface Foo {
    interface Sub extends Foo {}
}
'''

}

var cannedInput string = `1
1
1
2
2
2
4
4
5
`

func test() {
	// For #19868
	l := line{point{1 + zero, 2 + zero}, point{3 + zero, 4 + zero}}
	tinycall()                // this forces l etc to stack
	dx := l.end.x - l.begin.x //gdb-dbg=(l.begin.x,l.end.y)//gdb-opt=(l,dx/O,dy/O)
	dy := l.end.y - l.begin.y //gdb-opt=(dx,dy/O)
	sink = dx + dy            //gdb-opt=(dx,dy)
	// For #21098

            @Override
            public void buildFinished(BuildResult result) {
                artifactCachesProvider.getWritableCacheAccessCoordinator().useCache(() -> {
                    // forces cleanup even if cache wasn't used
                });
            }
        });
        return artifactCachesProvider;
    }

    @Provides
    ImmutableTransformWorkspaceServices createTransformWorkspaceServices(

			i = 0
		}
		if i > 0 {
			if _, err = w.w.Write(w.buf[:i]); err != nil {
				break
			}
			bn := copy(w.buf, w.buf[i:])
			w.buf = w.buf[:bn]
		}
	}
	return n, err
}

// Close forces data that remains in the buffer to be written.
func (w *normWriter) Close() error {
	if len(w.buf) > 0 {
		_, err := w.w.Write(w.buf)
		if err != nil {
			return err
		}
	}
	return nil
}