package main

import "runtime"
import "time"
import "os"

func init() {
	go func() {
		for {
			runtime.GC()
			runtime.Gosched()
		}
	}()
	go func() {
		time.Sleep(3 * time.Second)
		os.Exit(0)
	}()
}

var UsePackage = 0
var SINK interface{}

func main() {
	SINK = id1
	(*(*(id4))) <- (id5(1, 1)) * (byte(0))
	return
}

var id1 = uint(1)
var id4 = (**chan byte)(nil)

func id5(id6 int, id7 int) byte {
	select {
	case make(chan interface{}) <- (*(id8)):
		([]int16{})[1], (*(id59)) = <-(<-(<-(*(*((((([][]**chan chan chan int16{})[(*(*(*(([]***int{})[1])))):(*(*(*(id12)))):(*(id11))])[:(*(id10)):id6])[([]int{})[id13(1, "foo", uint(1), "foo")]])[(<-([]chan int{})[1])])))))
	case make(chan uint) <- uint(1):
	default:
	}
	_ = id6
	_ = id7
	return byte(0)
}

var id8 = (*interface{})(nil)
var id10 = (*int)(nil)
var id11 = (*int)(nil)
var id12 = (***int)(nil)

func id13(id32 int, id33 string, id34 uint, id35 string) int {
	switch {
	}
	for ([]int{})[1] = range []int{} {
	}
	id36 := (*uintptr)(nil)
	switch COND := (interface{})((*(id36))); COND.(type) {
	default:
		type id37 float64
		for ([]uintptr{})[1]--; false; (*(id38))-- {
			id39 := "foo"
			id40 := id37(1.1)
			id41 := (***uint)(nil)
			SINK = id40
			(*(*(*(id41)))) = uint(1)
			if false {
				make(chan [1]byte, 1) <- [1]byte{byte(0)}
				switch COND := (interface{})(([]map[uint]interface{}{})[1]); COND.(type) {
				}
				for false {
					switch {
					}
					id45 := (*****interface {
						id43(byte, *error, bool, map[byte]byte) ([0]bool, chan int, uint, *bool)
						id44([2]uint, uint, bool) (int, bool, error, float64)
					})(nil)
					([]id37{})[1]++
					switch COND := (interface{})(([]float64{})[1]); COND.(type) {
					case interface{}:
						id1++
						id46 := (*[1]interface{})(nil)
						id49 := interface {
							id48([]interface{}, *id37, [1]uint, string) ([]uintptr, uintptr)
						}(nil)
						break
						(*(*(*(*(*(id45)))))), id46, ([]byte{})[1] = interface {
							id43(byte, *error, bool, map[byte]byte) ([0]bool, chan int, uint, *bool)
							id44([2]uint, uint, bool) (int, bool, error, float64)
						}(nil), (*[1]interface{})(nil), byte(0)
						make(chan func(string, uintptr, uint, string) interface{}) <- ((func(string, uintptr, uint, string) interface{})(nil))
						if false {
							select {
							case make(chan byte) <- byte(0):
								id49 = interface {
									id48([]interface{}, *id37, [1]uint, string) ([]uintptr, uintptr)
								}(nil)
								if false {
									((func([2]int16, interface {
										id55(interface{}, error, string, uint) (interface{}, bool, byte, float64)
										id56(int16) (interface{}, error)
									}, [0]float64) (map[error]error, byte, interface {
										id50(bool, interface{}) (error, interface{}, int16, float64)
										id51(id37, int16) (string, uintptr)
										id52(string, int, byte) (error, id37)
										id53(uint, error, float64, string) (id37, byte, float64)
										id54(string, id37, string) (interface{}, uint, float64)
									}, bool))(nil))([2]int16{int16(1), int16(1)}, interface {
										id55(interface{}, error, string, uint) (interface{}, bool, byte, float64)
										id56(int16) (interface{}, error)
									}(nil), [0]float64{})
								} else {
								}
							case id57 := <-make(chan *int16, 1):
								_ = id57
							case id58 := <-make(chan [2]func(error, int16, int, int16) float64, 1):
								_ = id58
							case make(chan bool) <- false:
							}
						}
						_ = id46
						_ = id49
					default:
					}
					_ = id45
				}
			} else {
			}
			_ = id39
			_ = id40
			_ = id41
		}
	}
	_ = id36
	_ = id32
	_ = id33
	_ = id34
	_ = id35
	return 1
}

var id38 = (*uint)(nil)
var id59 = (*bool)(nil)

func init() {
	return
}
func init() {
	return
}