// Dir returns the direction of channel c.
func (c *Chan) Dir() ChanDir { return c.dir }

// Elem returns the element type of channel c.
func (c *Chan) Elem() Type { return c.elem }

func (c *Chan) Underlying() Type { return c }

func (l *PriorityList) remove(i int) interface{} {
    elem := l.elems[i]
    l.elems = append(l.elems[:i], l.elems[i+1:]...)
    return elem
}

func (l *PriorityList) Next() interface{} {
    return l.remove(l.Len() - 1)
}

var l *PriorityList

func Foo() {
    // It would fail here if instrumented code (including inline-label) was copied.
    for elem := l.Next(); elem != nil; elem = l.Next() {
    }

        std::cout << "Hello from clang!" << std::endl;
    #elif defined(__GNUC__) && defined(__MINGW32__)
        std::cout << "Hello from mingw!" << std::endl;
    #elif defined(__GNUC__) && defined(__CYGWIN__)
        std::cout << "Hello from gcc cygwin!" << std::endl;
    #elif defined(__GNUC__)
        std::cout << "Hello from gcc!" << std::endl;
    #elif defined(_MSC_VER)
        std::cout << "Hello from visual c++!" << std::endl;

	if errno != ENOSYS {
		return errno
	}

	rl := rlimit32{}
	if rlim.Cur == rlimInf64 {
		rl.Cur = rlimInf32
	} else if rlim.Cur < uint64(rlimInf32) {
		rl.Cur = uint32(rlim.Cur)
	} else {
		return EINVAL
	}
	if rlim.Max == rlimInf64 {
		rl.Max = rlimInf32
	} else if rlim.Max < uint64(rlimInf32) {
		rl.Max = uint32(rlim.Max)
	} else {
		return EINVAL
	}

type Pointer struct {
	base Type // element type
}

// NewPointer returns a new pointer type for the given element (base) type.
func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} }

// Elem returns the element type for the given pointer p.
func (p *Pointer) Elem() Type { return p.base }

func (p *Pointer) Underlying() Type { return p }

package types

// A Slice represents a slice type.
type Slice struct {
	elem Type
}

// NewSlice returns a new slice type for the given element type.
func NewSlice(elem Type) *Slice { return &Slice{elem: elem} }

// Elem returns the element type of slice s.
func (s *Slice) Elem() Type { return s.elem }

func (s *Slice) Underlying() Type { return s }

func Getrlimit(resource int, rlim *Rlimit) error {
	err := prlimit(0, resource, nil, rlim)
	if err != ENOSYS {
		return err
	}
	return getrlimit(resource, rlim)
}

// setrlimit prefers the prlimit64 system call. See issue 38604.
func setrlimit(resource int, rlim *Rlimit) error {
	err := prlimit(0, resource, rlim, nil)
	if err != ENOSYS {
		return err
	}

                    printf("clang");
                #elif defined(__GNUC__) && defined(__MINGW32__)
                    printf("mingw");
                #elif defined(__GNUC__) && defined(__CYGWIN__)
                    printf("gcc cygwin");
                #elif defined(__GNUC__)
                    printf("gcc");
                #elif defined(_MSC_VER)
                    printf("visual c++");
                #else

                    printf("clang");
                #elif defined(__GNUC__) && defined(__MINGW32__)
                    printf("mingw");
                #elif defined(__GNUC__) && defined(__CYGWIN__)
                    printf("gcc cygwin");
                #elif defined(__GNUC__)
                    printf("gcc");
                #elif defined(_MSC_VER)
                    printf("visual c++");
                #else

    cout << "amd64";
    #elif defined(__i386) || defined(_M_IX86)
    cout << "i386";
    #elif defined(_M_IA64)
    cout << "itanium";
    #else
    cout << "unknown";
    #endif
    cout << " ";

    #if defined(__linux__)
    cout << "linux";
    #elif defined(__APPLE__) && defined(__MACH__)
    cout << "os x";
    #elif defined(_WIN32) || defined (_WIN64) || defined (__CYGWIN__)