abstract class X<T> {
    fun <S> foo1(t: T): T = t
    fun <Q> foo2(t: T) {}
    fun <U> foo3() {}
}

	gwHTTPWildcard := makeConfig("foo3", "not-default", "*", "name3", "http", 8, "ingressgateway", "", networking.ServerTLSSettings_SIMPLE)
	gwTCPWildcard := makeConfig("foo4", "not-default-2", "*", "name4", "tcp", 8, "ingressgateway", "", networking.ServerTLSSettings_SIMPLE)

         sourceFile("cpp/foo2", "foo.cpp", """
            #include <iostream>
            #include "foo.h"
            using namespace std;

            void foo2() {
                cout << "foo2";
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        [sourceFile("headers", "foo.h", """
           void foo1();
           void foo2();
           """)
         ]

            #include <stdio.h>
            #include "foo.h"
            int main () {
               foo1();
               foo2();
               return 0;
            }
        """),

        sourceFile("c/foo1", "foo.c", """
            #include <stdio.h>
            #include "foo.h"

            void foo1() {
                printf("foo1");
            }
        """),

// license that can be found in the LICENSE file.

package main

type I interface{}

func foo1(i int) int     { return i }
func foo2(i int32) int32 { return i }
func main() {
	var i I
	i = 1
	var v1 = i.(int)
	if foo1(v1) != 1 {
		panic(1)
	}
	var v2 = int32(i.(int))
	if foo2(v2) != 1 {
		panic(2)
	}
	
	shouldPanic(p1)
}

func p1() {
	var i I
	i = 1

			watchTests: []*testWatchStruct{
				{basePod("t4-foo1"), true, watch.Added},
				{basePod("t4-foo2"), false, ""},
				{basePodUpdated("t4-foo1"), true, watch.Modified},
				{basePodUpdated("t4-foo2"), false, ""},
			},
		},
		{
			name:          "cluster-wide watch, request with name, field selector with metadata.name and spec.nodeName",
			requestedName: "t5-foo1",
			fieldSelector: fields.SelectorFromSet(fields.Set{

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package issue29563

//int foo1();
//int foo2();
import "C"

func Bar() int {
	return int(C.foo1()) + int(C.foo2())

        assertEquals("abc 123 xyz", fessXpathTransformer.removeCommentTag("abc<!-- foo1 -->123<!-- foo2 -->xyz"));
        assertEquals("abc ", fessXpathTransformer.removeCommentTag("abc<!---->"));
        assertEquals("abc -->", fessXpathTransformer.removeCommentTag("abc<!-- foo-->-->"));
        assertEquals("abc<!-- foo", fessXpathTransformer.removeCommentTag("abc<!-- foo"));

        def foo1 = Attribute.of("foo", String)
        def foo2 = Attribute.of("foo", String)
        def attr3 = Attribute.of("baz", String)

        given:
        candidate {
            attribute(attr3, "v2")
            attribute(foo1, "v2")
        }
        requested {
            attribute(attr3, "v3")
        }
        schema.getAttribute("foo") >> foo2

        when:

    return std::string(wide.begin(), wide.end());
}

void hello() {
    std::string foo1 = LoadStringFromResource(IDS_FOO1);
    std::string foo2 = LoadStringFromResource(IDS_FOO2);
    std::cout << foo1;
    std::cout << foo2;
}
"""),
        sourceFile("rc/dir1", "resources.rc", """
#include "hello.h"

STRINGTABLE
{
    IDS_FOO1, "foo1"
}
"""),
        sourceFile("rc/dir2", "resources.rc", """
#include "hello.h"