gistfile1.go

package main

var SINK interface{}

func main() {
	return
}
func init() {
	Var2, _, _ := (*(*(Var41))), error(nil), map[int]struct {
		Field1 uintptr
	}{}
	_ = Var2
	return
}

var Var41 = (func(Param44 map[interface {
	Method42(int16, uint, uint) (uint, interface{}, bool, int)
	Method43(rune, uintptr, uintptr) (bool, int16, int16)
}]interface{}, Param45 int16) []**byte {
	Var49(int16(1), rune(0))
	_ = Param44
	_ = Param45
	return []**byte{}
}(map[interface {
	Method42(int16, uint, uint) (uint, interface{}, bool, int)
	Method43(rune, uintptr, uintptr) (bool, int16, int16)
}]interface{}{}, int16(1)))[(int)((cap)(([][]string{})[((func(*uint, complex128, **string, string) int)(nil))((*uint)(nil), 1i, (**string)(nil), "foo")]))]
var Var49 = func(Param50 func(uintptr, int16, map[bool]byte, bool) ([]string, float32, func(string) int, complex128)) func(int16, rune) (interface{}, struct{}, chan bool, int) {
	select {
	case Var691 := <-(<-Var141([0]byte{}, interface{}(nil), interface{}(nil), [1]struct {
		Field140 byte
	}{})(byte(0), interface{}(nil), (struct {
		Field139 chan bool
	}{}), rune(0))):
		_ = Var691
	case Var692 = <-make(chan error, 1):
	case Var693, Var694 := <-make(chan byte, 1):
		_ = Var693
		_ = Var694
	case make(chan [0][2]complex128) <- [0][2]complex128{}:
	case Var695, (([][1]bool{})[((func(map[complex64]string) int)(nil))(make(map[complex64]string))])[(struct {
		Field814 int
	}{}).Field814] = <-make(chan map[complex64]map[uint]float64):
	case ([]interface{}{})[(Var296)-(1)] = <-make(chan interface{}):
	default:
	}
	_ = Param50
	return ((func(int16, rune) (interface{}, struct{}, chan bool, int))(nil))
}(((func(uintptr, int16, map[bool]byte, bool) ([]string, float32, func(string) int, complex128))(nil)))
var Var141 = (((*(Var142))[(Var143)-(*(*((([][1]**int{})[((func(interface {
	Method178(map[float32]complex128, error) (uintptr, string)
}, [2][2]string) int)(nil))(interface {
	Method178(map[float32]complex128, error) (uintptr, string)
}(nil), [2][2]string{})])[(struct {
	Field215 int
}{}).Field215])))])[:])[Var296]
var Var296 = Func297(uint(1))

func Func297(Param302 uint) int {
	if ((<-make(chan [][2]func([]float32, func(func(float32) complex128) (struct {
		Field303 float64
	}, uintptr, int16, struct {
		Field304 bool
		Field305 rune
		Field306 uint
	}), map[*uint]*int, chan func(uintptr) (float64, int)) bool))[(int)((*(*(((<-make(chan [][2]**[1]int, 1))[Var337])[(*(*(((([0][][1]**int{})[(make(map[error]int))[error(nil)]])[(((*(Var447))[(int)((*(Var648))[(int)(([]uint{})[((func(interface{}, [][1]error) int)(nil))(interface{}(nil), [][1]error{})])])]).Field396)-(1)])[(<-make(chan int, 1))])))])))[((Var690)[(<-make(chan int, 1))])+(1)])])[((func(error, interface{}) int)(nil))(error(nil), interface{}(nil))]([]float32{}, ((func(func(float32) complex128) (struct {
		Field303 float64
	}, uintptr, int16, struct {
		Field304 bool
		Field305 rune
		Field306 uint
	}))(nil)), map[*uint]*int{}, make(chan func(uintptr) (float64, int), 1)) {
	}
	_ = Param302
	return 1
}

var Var447 = (Var448)[func(Param479 interface{}, Param480 map[struct{}]rune) int {
	type Type481 complex64
	type Type482 struct{}
	Var503 := ((func([0]interface{}, [0]chan uint, *float64) func(uint, map[interface{}]complex64, bool) int)(nil))
	Var547 := [0][1][2][]error{}
	Var499 := Var503([0]interface{}{}, [0]chan uint{}, (*float64)(nil))
	Var491 := (*chan float32)(nil)
	Var522 := (***[2]map[uint]*uintptr)(nil)
	Var498 := (Var499(uint(1), make(map[interface{}]complex64), false)) + (1)
	Var549 := (*[2]int)(nil)
	Var548 := [1]int{}
	Var580 := (*[0][0]string)(nil)
	Var550 := 1.0
	Var578 := [0]****[0]float32{}
	Var587 := uint(1)
	Var579 := [2]string{}
	Var586 := "foo"
	Var613 := [1]*[2]*bool{}
	((((((([0][][][2][][1][0]float32{})[(Var498)-(1)])[(int)(([]uint{})[(<-make(chan int))])])[((func(int) int)(nil))(1)])[(map[Type481]int{})[Type481(complex64(1i))]])[(<-make(chan int))])[(int)((len)((*(*(*(Var522))))[(int)(([]uint{})[((((([][0][1][1]int{})[((func(*byte, uint) int)(nil))((*byte)(nil), uint(1))])[(int)(([]int{})[(int)(([]int16{})[(int)((cap)((((Var547)[(Var548)[((*(Var549))[(int)(Var550)])-(1)]])[(<-make(chan int))])[(int)((*(*(*(*((Var578)[(int)((len)((Var579)[((func(interface{}, uint, string, float64) int)(nil))(interface{}(nil), uint(1), "foo", 1.0)]))])))))[(int)((len)(((*(Var580))[([]int{})[(int)((len)(Var586))]])[(int)(Var587)]))])]))])])])[(make(map[*int]int, 1))[(*int)(nil)]])[((func(map[float64]map[rune]string) int)(nil))(make(map[float64]map[rune]string, 1))])-(1)])]))])[((func(interface{}, interface{}) int)(nil))(interface{}(nil), interface{}(nil))], (*((*((Var613)[(int)((len)(([]string{})[(<-make(chan int, 1))]))]))[((func(struct{}, struct {
		Field614 []float64
	}) int)(nil))((struct{}{}), (struct {
		Field614 []float64
	}{}))])) = <-(*(Var491))
	_ = Var503
	_ = Var547
	_ = Var499
	_ = Var491
	_ = Var522
	_ = Var498
	_ = Var549
	_ = Var548
	_ = Var580
	_ = Var550
	_ = Var578
	_ = Var587
	_ = Var579
	_ = Var586
	_ = Var613
	_ = Param479
	_ = Param480
	return 1
}(interface{}(nil), map[struct{}]rune{})]
var Var690 = [2]int{}
var Var692 = error(nil)
var Var695 = make(map[complex64]map[uint]float64, 1)

func init() {
	return
}

var Var448 = (<-(<-(*(Var982))))[(*(((*(*(*(Var1026))))[(<-Var1154)])[((*((Var1240)[(*(Var1292))[(<-make(chan int))]]))[(<-make(chan int, 1))])[(*((Var1996)[(make(map[byte]int, 1))[byte(0)]]))+(1)]]))]
var Var1026 = (<-Var1109)
var Var1292 = (((([][][]*[2]int{})[:])[(([]struct {
	Field1313 int
}{})[(int)(Var1314)]).Field1313])[(*(*(([]**func([2]struct {
	Field1430 int
}) func(*rune) int{})[(*((Var1557)[((func([]map[uintptr]uintptr) int)(nil))([]map[uintptr]uintptr{})]))])))([2]struct {
	Field1430 int
}{})((*rune)(nil))])[(([]int{})[(int)((*(*(([]**[2]byte{})[([]int{})[((func(interface{}, struct {
	Field1916 uint
	Field1917 error
}) int)(nil))(interface{}(nil), (struct {
	Field1916 uint
	Field1917 error
}{}))]])))[(<-make(chan int))])])-(1)]
var Var1557 = (<-(([]chan [2][0]*int{})[Var1599:(Var1600)[(int)((*((([][2]*byte{})[((([][1]int{})[(int)((len)(((([][1][2]string{})[([]int{})[([]int{})[(int)((*((Var1647)[(Var1649)-(1)])))]]])[(make(map[[0]int16]int, 1))[[0]int16{}]])[(int)(([]uint{})[(<-make(chan int))])]))])[((Var1792).Field1790)-(1)])+(1)])[(map[[1]complex128]int{})[[1]complex128{}]])))]])[((*((([][0]*[2]int{})[((func(rune, struct {
	Field1818 float32
}, *chan uint, bool) int)(nil))(rune(0), (struct {
	Field1818 float32
}{}), (*chan uint)(nil), false)])[(([]int{})[(int)((*((Var1897)[(<-make(chan int))])).Field1854)])+(1)]))[(int)((*(Var1898)))])-(1)])[(Var1915)[(int)(([]int16{})[(<-make(chan int))])]]
var Var1647 = [2]*uintptr{0: Var1648, 1: (*uintptr)(nil)}
var Var1649 = (1) * ((*(([]*[]func(complex128, struct {
	Field1650 func(string) (rune, float32)
}, int, chan [2]float64) int{})[(*(*((([][2]**int{})[(Var1725)+(1)])[([]int{})[(<-make(chan int))]])))+(1)]))[(*(Var1783))](1i, (struct {
	Field1650 func(string) (rune, float32)
}{}), 1, make(chan [2]float64)))
var Var1725 = 1
var Var1783 = (*int)(nil)
var Var1897 = [0]*struct {
	Field1852 complex64
	Field1853 [2]int
	Field1854 float64
}{}
var Var1996 = [2]*int{}
var Var1915 = [...]int{(<-(*(([]*func(func(*interface{}) ([0]error, [0]string), error) chan int{})[(<-make(chan int))]))(func(Param2128 *interface{}) ([0]error, [0]string) {
	for _, Var2335 = range (<-([]chan [2]func([1]complex128) string{})[((func(complex64, int16, byte) int)(nil))(complex64(1i), int16(1), byte(0))])[((func(rune, uint, struct{}, *[2]int) int)(nil))(rune(0), uint(1), (struct{}{}), (*[2]int)(nil))]([1]complex128{}) {
		continue
		Var3249 := (*int)(nil)
		Var3215 := byte(0)
		Var3379 := [1]**int{}
		Var2693 := Var2694
		type Type2430 func([]interface{}, [0]uintptr, byte) (interface{}, interface{}, chan string)
		Var3293 := interface {
			Method3292(rune, func(complex64, bool, uint, bool) (string, float32, int, string), *float32) bool
		}(nil)
		if (((([][2]struct {
			Field2466 bool
		}{})[(*(([]*int{})[(struct {
			Field2642 int
			Field2643 struct{}
		}{}).Field2642])):(*(Var3249)):(*((Var2693)[(([]int{})[(int)(([]int{})[((([][0]int{})[(int)(Var3215)])[(int)((cap)((*(([]*[1][][]error{})[((Var3248)[((func(string, float32) int)(nil))("foo", float32(1.0))])-(1)]))[(<-make(chan int, 1))]))])-(1)])])+(1)]))])[(<-make(chan int, 1))])[(<-make(chan int))]).Field2466 {
			SINK = Var3293
			return [0]error{}, [0]string{}
		}
		continue
		switch _, Var3294 := rune(0), complex64(1i); {
		case false:
			defer close(make(chan bool))
			Type2430(((func([]interface{}, [0]uintptr, byte) (interface{}, interface{}, chan string))(nil)))([]interface{}{}, [0]uintptr{}, byte(0))
		default:
			(*(*((Var3379)[((func([]error) int)(nil))([]error{})])))++
			_ = Var3294
			_ = Var3294
		}
		_ = Var3249
		_ = Var3215
		_ = Var3379
		_ = Var2693
		_ = Var3293
	}
	_ = Param2128
	return [0]error{}, [0]string{}
}, error(nil)))}
var Var2335 = (rune)((<-make(chan byte, ([]int{})[([]int{})[(int)(([]float64{})[(struct {
	Field2426 complex128
	Field2427 bool
	Field2428 interface{}
	Field2429 int
}{}).Field2429])]])))
var Var2694 = Var2843
var Var2843 = (*(([]*[0]*int{})[(((append((<-make(chan [][2]int, 1)), (<-(*(([]*chan [][2]int{})[(make(map[int16]int, 1))[int16(1)]])))...))[(*((Var3068)[((([][0]int{})[(<-make(chan int, 1))])[((func(struct{}, func(int) func(rune, string) (int, uint)) int)(nil))((struct{}{}), ((func(int) func(rune, string) (int, uint))(nil)))])+(1)]))+(1)])[((func(int, complex128, int, uint) int)(nil))(1, 1i, 1, uint(1))])+(1)]))
var Var3068 = [2]*int{}
var Var3248 = [0]int{}
var Var1898 = (*float32)(nil)
var Var1792 = (struct {
	Field1789 []interface{}
	Field1790 int
	Field1791 int16
}{})
var Var1648 = (*uintptr)(nil)
var Var1600 = [2]int{}
var Var1599 = 1
var Var1314 = 1
var Var1240 = []*[1][2]int{}
var Var1154 = make(chan int)
var Var1109 = make(chan ***[0][]*int)
var Var982 = (*chan chan [2][]*[0]struct {
	Field396 int
	Field397 float64
	Field398 float64
})(nil)
var Var648 = (*[1]float64)(nil)
var Var337 = 1
var Var143 = 1
var Var142 = (*[][]func([0]byte, interface{}, interface{}, [1]struct {
	Field140 byte
}) func(byte, interface{}, struct {
	Field139 chan bool
}, rune) chan chan [1]map[float64]complex128)(nil)