)

func main() {
	println(c1 / c1)
	println(c2 / c2)
	println(c3 / c3)
	println(c4 / c4)
	println(c5 / c5)
	println(c6 / c6)
	println(c7 / c7)
	println(c8 / c8)
	println(c9 / c9)
	println(c10 / c10)
	println(c20 / c20)
	println(c30 / c30)
	println(c40 / c40)
	println(c50 / c50)
	println(c60 / c60)
	println(c70 / c70)
	println(c80 / c80)
	println(c90 / c90)

	ipv4Public := net.ParseIP("8.8.8.8")
	ipv4Broadcast := net.ParseIP("255.255.255.255")

	fmt.Println(ipv6Global.IsGlobalUnicast())
	fmt.Println(ipv6UniqLocal.IsGlobalUnicast())
	fmt.Println(ipv6Multi.IsGlobalUnicast())

	fmt.Println(ipv4Private.IsGlobalUnicast())
	fmt.Println(ipv4Public.IsGlobalUnicast())
	fmt.Println(ipv4Broadcast.IsGlobalUnicast())

	// Output:
	// true
	// true
	// false
	// true

	s := []int{5, 2, 6, 3, 1, 4} // unsorted
	sort.Ints(s)
	fmt.Println(s)
	// Output: [1 2 3 4 5 6]
}

func ExampleIntsAreSorted() {
	s := []int{1, 2, 3, 4, 5, 6} // sorted ascending
	fmt.Println(sort.IntsAreSorted(s))

	s = []int{6, 5, 4, 3, 2, 1} // sorted descending
	fmt.Println(sort.IntsAreSorted(s))

	s = []int{3, 2, 4, 1, 5} // unsorted
	fmt.Println(sort.IntsAreSorted(s))

	// Output: true
	// false
	// false

                    System.out.println("beforeTest out");
                    System.err.println("beforeTest err");
                }

                @Test public void m1() {
                    System.out.println("m1 out");
                    System.err.println("m1 err");
                }

                @Test public void m2() {
                    System.out.println("m2 out");

            qualifiers: List<KaClassTypeQualifier>,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer {
                printCollection(qualifiers, separator = ".") { qualifier ->
                    qualifier.render(analysisSession, type, typeRenderer, printer)
                }
            }
        }
    }

	check("nil-deref-1", func() { println(p[1]) }, "nil pointer dereference")
	check("nil-deref-big", func() { println(q[5000]) }, "nil pointer dereference")

	i = 99999
	var sl []int
	p1 := new([10]int)
	check("array-bounds", func() { println(p1[i]) }, "index out of range")
	check("slice-bounds", func() { println(sl[i]) }, "index out of range")

	var inter interface{}
	inter = 1

				if c != expect {
					t.Errorf("%s: compare(%v,%v)=%d; expect %d", v0.Type(), v0, v1, c, expect)
				}
			}
		}
	}
}

type sortTest struct {
	data  any    // Always a map.
	print string // Printed result using our custom printer.
}

var sortTests = []sortTest{
	{
		map[int]string{7: "bar", -3: "foo"},
		"-3:foo 7:bar",
	},
	{
		map[uint8]string{7: "bar", 3: "foo"},
		"3:foo 7:bar",
	},
	{

        System.out.println("\n\n");
        System.out.println("Parent SCM URL is: " + project0.getScm().getUrl());
        System.out.println("Child SCM URL is: " + project1.getScm().getUrl());
        System.out.println();
        System.out.println("Parent SCM connection is: " + project0.getScm().getConnection());
        System.out.println("Child SCM connection is: " + project1.getScm().getConnection());

If the named path is a directory, fix rewrites all .go files in that
directory tree.  When fix rewrites a file, it prints a line to standard
error giving the name of the file and the rewrite applied.

If the -diff flag is set, no files are rewritten. Instead fix prints
the differences a rewrite would introduce.

The -r flag restricts the set of rewrites considered to those in the

  optional bool enable_timing = 4 [default = false];

  // Prints MLIR before specified passes. Supports regular expressions for
  // matching against the names of the desired passes.
  optional string print_ir_before = 5 [default = ""];

  // Prints MLIR after specified passes. Supports regular expressions for
  // matching against the names of the desired passes. Currently only prints
  // after a pass if the MLIR is mutated.