gistfile1.go

package main

var SINK interface{}

func main() {
	(<-make(chan chan chan uint)) <- (((<-make(chan [0][][0]chan uint))[(int)(Var110)])[(int)(((Var220)[:])[(*((([][2]*int{})[Var221])[((Var253)[((func(chan byte) int)(nil))(make(chan byte))])-(1)]))])])[(make(map[int16]int))[int16(1)]]
	Var491 := (*int)(&(((Var553)[([]int{})[(<-make(chan int, 1))]])[(make(map[uint]int, 1))[uint(1)]]))
	Var346 := (*[][0]*func(float32) *chan interface{})(&((*(*(Var375)))[(*(Var491))-(1)]))
	var Var255 *chan interface{} = (*(((*(Var346))[(make(map[int16]int))[int16(1)]])[(Var797)+(1)]))(float32(1.0))
	Var989 := (**[0]*[0]string)(nil)
	for Var924, _ := range make(map[uintptr][2]int, 1) {
		([]error{})[((func(interface{}, error, chan struct{}, float32) int)(nil))(interface{}(nil), error(nil), make(chan struct{}), float32(1.0))], ([]bool{})[(int)((len)((*((*(*(Var989)))[(int)(Var797)]))[(<-make(chan int, 1))]))] = <-make(chan error)
		Var990 := uint(1)
		Var1168 := (**int)(nil)
		SINK = Var990
		Var1114 := [1]int{}
		if false {
			switch Var990++; {
			default:
			}
		Label1169:
			Var1170 := interface{}(nil)
			if ([]int{})[(int)((cap)(((([][1][0]chan *complex64{})[(int)((len)(([]string{})[(Var1114)[(int)((len)(Var658))]]))])[(*(*(Var1168)))])[(<-make(chan int))]))]--; false {
				goto Label1169
				switch COND := (interface{})(Var1170); COND.(type) {
				}
			}
			_ = Var1170
		} else {
		}
		_ = Var990
		_ = Var1168
		_ = Var1114
		_ = Var924
	}
	_ = Var491
	_ = Var346
	_ = Var255
	_ = Var989
	return
}

var Var110 = (*(*(Var219)))
var Var375 = (**[1][][0]*func(float32) *chan interface{})(&(((*(Var486))[(Var490)[(<-([2]chan *uintptr{})[((func(bool, complex64, map[[0]float64]float64, rune) int)(nil))(false, complex64(1i), make(map[[0]float64]float64, 1), rune(0))])]])[((func([]chan uintptr, error, int16) int)(nil))([]chan uintptr{}, error(nil), int16(1))]))
var Var553 = (((*(*(*(((Var640)[(<-make(chan int))])[(int)((len)(Var657))]))))((<-make(chan complex64, 1))))[(int)((len)(Var658))])[(*(*(*(([]***int{})[(Var797)-(1)]))))+(1)]
var Var658 = ((func(error) string)(nil))(error(nil))
var Var797 = 1

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

var Var640 = (Var1171)[(int)((len)(((func(Param1173 rune, Param1174 complex128) [][1]string {
	Var1176 := (*(*((Var1209)[((*(*(([]**[]struct {
		Field1227 *int16
		Field1228 *uintptr
		Field1229 int
	}{})[(int)((*(([]*int16{})[(Var1230)-(1)])))])))[(int)((cap)((([]chan func(error) (string, complex64, int16){})[(*(*(*(([]***[0]int{})[Var1230]))))[(<-make(chan int))]:])[(int)(Var1440)]))]).Field1229])))(1.0)
	Var1700 := [1][2]uintptr{}
	Var1607 := Var1608
	Var1870 := [0]*chan int{}
	Var1731 := "foo"
	Var1606 := (<-(*((Var1607)[((([][][1]int{7: [][1]int{}})[((func(float64, map[interface{}][]error, chan struct{}) func(int, rune, complex64) int)(nil))(1.0, map[interface{}][]error{}, make(chan struct{}, 1))(1, rune(0), complex64(1i))])[(int)(((Var1700)[(int)(([]float32{})[(int)((len)(Var1731))])])[(([][2]int{})[(int)(Var1230)])[(int)((len)((*((Var1870)[(([]int{})[((func([2]rune, interface{}, map[chan rune]interface{}) int)(nil))([2]rune{}, interface{}(nil), make(map[chan rune]interface{}, 1))])-(1)]))))]])])[(([]int{})[(*(Var1892))[((func(float64, chan *uintptr, int, *func(complex64, float64) (uintptr, complex128)) int)(nil))(1.0, make(chan *uintptr), 1, (*func(complex64, float64) (uintptr, complex128))(nil))]])+(1)]])))
	Var1524 := (**[0][]chan *[][1]string)(nil)
	Var2192 := ((func(func(bool, int) (uint, uint), float64, []bool) ([]rune, bool))(nil))
	Var1472 := (<-((*(*(Var1524)))[(<-make(chan int))])[func(Param1598 float64) int {
		if make(chan *bool) <- (*bool)(&(Var1606)); false {
			_, Var1893 := interface{}(nil), int16(1)
			Var1988 := (*[1]**[1][1]byte)(nil)
			type Type1894 error
			Var1903 := (*byte)(nil)
			Var1907 := [1][2]int16{}
			select {
			case make(chan float64) <- 1.0:
				select {
				case make(chan struct{}) <- (struct{}{}):
					switch COND := (interface{})(([]interface {
						Method1895(uint) (int, struct {
							Field1896 int16
						})
						Method1897(byte, Type1894, int, struct {
							Field1898 byte
						}) []uint
						Method1899(string, [2]Type1894, string, map[uintptr]complex128) (int16, uintptr, string, bool)
						Method1900(chan int, []Type1894, map[interface{}]float64, map[complex128]byte) (rune, func(string, byte, bool) (int16, int), complex128)
					}{})[(Var1230)+(1)]); COND.(type) {
					case struct {
						Field1901 int
						Field1902 int16
					}:
						(*(Var1903)) = byte(0)
					Label1904:
						goto Label1904
					}
				case make(chan interface {
					Method1905(map[float64]float64, *uint, complex64, byte) (map[complex128]string, func(int, byte, string) (float64, float64, float64))
					Method1906(complex64) (chan float32, string)
				}) <- interface {
					Method1905(map[float64]float64, *uint, complex64, byte) (map[complex128]string, func(int, byte, string) (float64, float64, float64))
					Method1906(complex64) (chan float32, string)
				}(nil):
				case ((Var1907)[(int)((([][2]int{})[(int)(((*(*((*(Var1988))[((func(map[complex64]*Type1894) int)(nil))(map[complex64]*Type1894{})])))[(<-make(chan int, 1))])[(Var1230)+(1)])])[((func(func(*bool, chan string, uint, int16) (float32, int16, int, int), int) int)(nil))(((func(*bool, chan string, uint, int16) (float32, int16, int, int))(nil)), 1)])])[(make(map[chan error]int))[make(chan error)]] = <-make(chan int16, 1):
				case Var2089 := <-make(chan interface{}):
					_ = Var2089
				case make(chan struct{}, 1) <- (struct{}{}):
				case make(chan int) <- 1:
				case Var2192 = <-make(chan func(func(bool, int) (uint, uint), float64, []bool) ([]rune, bool), 1):
				case Var2193, Var2194 := <-make(chan uint, 1):
					_ = Var2193
					_ = Var2194
				case make(chan interface{}, 1) <- interface{}(nil):
				case make(chan [2]int) <- [2]int{}:
				}
			case Var2195 := <-make(chan bool, 1):
				_ = Var2195
			default:
			}
			_ = Var1893
			_ = Var1988
			_ = Var1903
			_ = Var1907
		}
		_ = Param1598
		return 1
	}(1.0)])
	return (*(Var1472))
	_ = Var1176
	_ = Var1700
	_ = Var1607
	_ = Var1870
	_ = Var1731
	_ = Var1606
	_ = Var1524
	_ = Var2192
	_ = Var1472
	_ = Param1173
	_ = Param1174
	return [][1]string{}
}(rune(0), 1i))[(*(Var2305))])[((func(chan struct {
	Field2306 complex64
}, [1]bool) int)(nil))(make(chan struct {
	Field2306 complex64
}), [1]bool{})]))]
var Var1230 = Func1231(([...]bool{})[(<-(*(Var1258)))], ([...]complex128{(1i) * (1i)})[(<-make(chan int))])
var Var1258 = (*chan int)(nil)
var Var2305 = (*int)(nil)
var Var490 = make(map[*uintptr]int)
var Var253 = [1]int{}
var Var220 = []rune{}
var Var219 = (**uintptr)(nil)

func Func1231(Param2307 bool, Param2308 complex128) int {
	for *(([]*bool{(<-make(chan *bool))})[((*(Var2422))[(struct {
		Field4885 interface{}
		Field4886 int
	}{}).Field4886])-(1)]) {
		continue
		go panic(error(nil))
		defer ((func(string, interface {
			Method4892(bool, complex64) (byte, complex128, rune)
		}) (interface{}, map[complex64]bool, bool, float64))(nil))("foo", interface {
			Method4892(bool, complex64) (byte, complex128, rune)
		}(nil))
		Var4893, Var4894 := <-make(chan struct{})
		break
		_ = Var4893
		_ = Var4894
	}
	for Var4895 := ((func([]error, [2]byte, map[int]complex128, rune) (complex128, *complex64))(nil)); false; make(chan struct {
		Field4908 interface{}
		Field4909 uint
	}) <- (struct {
		Field4908 interface{}
		Field4909 uint
	}{}) {
		go print((*int)(nil), 1.0, 1.0)
		go ((func(byte, struct {
			Field4913 uint
			Field4914 bool
		}) float32)(nil))(byte(0), (struct {
			Field4913 uint
			Field4914 bool
		}{}))
		break
		go ((func([]complex64, float64, map[bool]byte) (map[uintptr]bool, byte))(nil))([]complex64{}, 1.0, make(map[bool]byte))
		select {
		case Var4916 = <-make(chan []uintptr):
		case make(chan complex128) <- 1i:
		case make(chan string, 1) <- "foo":
		case Var4917, Var4918 := <-make(chan string, 1):
			_ = Var4917
			_ = Var4918
		}
		_ = Var4895
	}
	_ = Param2307
	_ = Param2308
	return 1
}

var Var2422 = Var2474(rune(0))
var Var2474 = ([]func(rune) *[]int{})[(*(*(Var2530)))((struct {
	Field2475 string
}{}))]
var Var2530 = (*(*(((((func(map[int16][]error) [2][]**[]**func(struct {
	Field2475 string
}) int)(nil))(map[int16][]error{}))[Var2534])[Var3424])))[(<-make(chan int))]
var Var2534 = ([]int{})[(int)(((((([]func([0]map[int16]complex64) [][1][0]int{})[:Var2710])[(int)((([][0]int{})[((func(struct{}, int16, interface{}) int)(nil))((struct{}{}), int16(1), interface{}(nil))])[((func(int16) int)(nil))(int16(1))])]([0]map[int16]complex64{}))[(int)((len)(Var4808))])[((func([2]uintptr, float32, struct {
	Field4809 chan byte
	Field4810 func(error, uintptr, byte) (uintptr, uintptr, error)
	Field4811 interface{}
	Field4812 bool
}, interface{}) int)(nil))([2]uintptr{}, float32(1.0), (struct {
	Field4809 chan byte
	Field4810 func(error, uintptr, byte) (uintptr, uintptr, error)
	Field4811 interface{}
	Field4812 bool
}{}), interface{}(nil))])[(<-make(chan int))])]
var Var2710 = (int)((<-make(chan [2]rune))[(((*(Var2783))[((func(float32, map[rune]interface{}, chan []complex128, int) int)(nil))(float32(1.0), make(map[rune]interface{}, 1), make(chan []complex128, 1), 1)])[(<-make(chan int, 1))])+(1)])
var Var2783 = ((*((([][]*[2][]*[][1]int{})[(((((([][0][1][2][1]int{})[(int)((*(((*(((Var3039)[(struct {
	Field3563 int
	Field3564 [1]error
}{}).Field3563])[((Var3565)[((*(Var3702))[([]int{})[(int)(([]byte{})[(([]int{})[Var3424])+(1)])]])[((func(uint) int)(nil))(uint(1))]])-(1)]))[((func(string, func(chan interface{}, struct{}, complex64, int16) complex128, int) int)(nil))("foo", ((func(chan interface{}, struct{}, complex64, int16) complex128)(nil)), 1)])[(*(([]*int{})[(<-make(chan int))]))]))[(int)((*(([]*int16{})[(*(Var3912))])))])])[(<-make(chan int))])[(<-make(chan int, 1))])[(*((Var4111)[(struct {
	Field4123 uintptr
	Field4124 int
}{}).Field4124]))[(*(Var4323))]])[((*((Var4390)[(<-make(chan int, 1))]))[(int)(((*((Var4462)[(<-make(chan int))]))[((func(map[struct{}]func(complex64, float64, uintptr, int) (interface{}, float32), struct{}, struct{}, int) int)(nil))(make(map[struct{}]func(complex64, float64, uintptr, int) (interface{}, float32)), (struct{}{}), (struct{}{}), 1)])[(struct {
	Field4683 chan float64
	Field4684 byte
	Field4685 struct {
		Field4686 bool
	}
	Field4687 int
}{}).Field4687])])+(1)])-(1)])[((func([1]byte) int)(nil))([1]byte{})]))[([]int{})[(*((*(([]*[1]*int{})[((func(string) int)(nil))("foo")]))[(int)((*(Var4688))[((func(float32) int)(nil))(float32(1.0))])]))]])[(int)(([]float32{})[((([]struct {
	Field4771 rune
	Field4772 interface{}
	Field4773 uintptr
	Field4774 map[complex64]float64
	Field4775 int
	Field4776 byte
	Field4777 int16
	Field4778 struct {
		Field4779 error
	}
	Field4780 complex128
	Field4781 string
	Field4782 float32
}{})[((func(struct{}, *error, uintptr) int)(nil))((struct{}{}), (*error)(nil), uintptr(0))]).Field4775)-(1)])]
var Var3039 = Var3040
var Var3040 = Var3041(float32(1.0))
var Var3041 = (Var3042)[(*(([]*int{})[(int)((len)(((*(Var3148))[(((([][1][0]int{})[(int)((len)((*(([]*string{})[(int)((Var3149)[(((*(((([][1][0]*[2][1]int{})[(int)((Var3349)[((func(map[float32]*int) int)(nil))(map[float32]*int{})])])[([]int{})[(int)((len)((([]struct {
	Field3388 []bool
	Field3389 string
	Field3390 struct {
		Field3391 int
	}
	Field3392 complex64
}{})[(int)(Var3423)]).Field3389))]])[(<-make(chan int))]))[(([]int{})[([]int{})[(Var3424)-(1)]])+(1)])[((Var3427).Field3426)+(1)])+(1)])]))))])[(int)((len)(([]string{})[(<-make(chan int, 1))]))])[((func(*[0]bool, interface{}, chan byte) int)(nil))((*[0]bool)(nil), interface{}(nil), make(chan byte))])-(1)])[(int)(([]byte{})[(((([][0]struct {
	Field3539 int
	Field3540 chan float64
}{})[(<-make(chan int))])[(int)(Var3543)]).Field3539)+(1)])]))]))]
var Var3042 = Var3043
var Var3043 = []func(float32) [2][1]*[2][0]*[2]uint{9: ([...]func(float32) [2][1]*[2][0]*[2]uint{([]func(float32) [2][1]*[2][0]*[2]uint{})[(int)((([][0]int{})[(([]int{})[((func(uintptr) int)(nil))(uintptr(0))])+(1)])[((func(interface{}, float64) int)(nil))(interface{}(nil), 1.0)])]})[(<-make(chan int, 1))]}
var Var3148 = (*[2][0][]string)(nil)
var Var3149 = [1]float64{}
var Var3349 = [2]uint{}
var Var3423 = rune(0)
var Var3424 = 1
var Var3427 = (struct {
	Field3426 int
}{})
var Var3543 = byte(0)
var Var3565 = [0]int{}
var Var3702 = (*[2][2]int)(nil)
var Var3912 = (*int)(nil)
var Var4111 = [2]*[0]int{}
var Var4323 = (*int)(nil)
var Var4390 = [1]*[0]int{}
var Var4462 = [0]*[1][1]uintptr{}
var Var4688 = (*[1]rune)(nil)
var Var4808 = "foo"
var Var4916 = []uintptr{}
var Var1892 = (*[1]int)(nil)
var Var1608 = [1]*chan bool{}
var Var1440 = byte(0)
var Var1209 = [2]**func(float64) func(struct{}, interface {
	Method1175(interface{}, complex64) (uint, float32)
}) bool{}
var Var1171 = [2][1][0]***func(complex64) [2][1][][]int{}
var Var657 = "foo"
var Var486 = (*[2][]*[1][][0]*func(float32) *chan interface{})(nil)
var Var221 = 1