gistfile1.go

package b

var Var2694 = Var2695

var Var2695 = (Var2696)[((func([][]rune, interface {
	Method4351(chan interface{}, []int, uint) (complex128, *bool)
}, interface{}, float64) int)(nil))([][]rune{}, interface {
	Method4351(chan interface{}, []int, uint) (complex128, *bool)
}(nil), interface{}(nil), 1.0)](false, error(nil))
var Var2696 = Var2743
var Var2743 = ([]func(bool, error) [1]int{})[:([]int{})[(Var2744)[(int)((*(([]*uintptr{})[([]int{})[(([]int{})[(*(*(*(([]***[1]int{})[(int)((len)((*(*(*((([][1]***map[struct{}][0]bool{})[(*(Var4287))])[(int)((*(Var4348)).Field4347)]))))))]))))[((func(chan map[bool]bool, struct {
	Field4349 interface {
		Method4350(byte) (complex64, interface{})
	}
}, uint) int)(nil))(make(chan map[bool]bool), (struct {
	Field4349 interface {
		Method4350(byte) (complex64, interface{})
	}
}{}), uint(1))]])-(1)]])))]]:(*(((<-((func(func(interface{}, byte, struct{}, *byte) (func(complex128, rune) (interface{}, rune), *error, [2]rune, chan bool), [][0]error, [0]byte, **interface{}) chan [2][]*int)(nil))(((func(interface{}, byte, struct{}, *byte) (func(complex128, rune) (interface{}, rune), *error, [2]rune, chan bool))(nil)), [][0]error{}, [0]byte{}, (**interface{})(nil)))[((func(complex64, error, interface{}, []rune) int)(nil))(complex64(1i), error(nil), interface{}(nil), []rune{})])[(<-make(chan int, 1))]))]
var Var2744 = [2]int{0: (*((*((((func(interface{}) []*[2]*func(struct{}) int)(nil))(interface{}(nil)))[(int)(Var2745)]))[func(Param2746 float32, Param2747 struct{}, Param2748 complex128) int {
	_ = Param2746
	_ = Param2747
	_ = Param2748
	return (func(Param2751 chan interface {
		Method2749(error, complex64, uint, bool) (float64, complex128, rune, bool)
		Method2750(rune, error, complex128) (rune, float64, rune, uint)
	}, Param2752 uint, Param2753 rune, Param2754 *rune) [1]int {
		(<-(*(*((Var2852)[(int)(([]int16{})[(((Var3255)[(int)(([]uintptr{})[((*((([][1]*[0]int{})[((func(map[byte]int16, rune, int) int)(nil))(make(map[byte]int16), rune(0), 1)])[(int)((len)((*((Var3341)[(struct {
			Field3344 int
			Field3345 struct{}
			Field3346 string
		}{}).Field3344]))))]))[(struct {
			Field3374 []string
			Field3375 int
			Field3376 func(string, float32, float32) int
			Field3377 float32
		}{}).Field3375])+(1)])])[(([]int{})[(Var3402)[((func(struct {
			Field3403 struct {
				Field3404 complex64
			}
			Field3405 int
			Field3406 complex64
			Field3407 complex64
		}, rune) int)(nil))((struct {
			Field3403 struct {
				Field3404 complex64
			}
			Field3405 int
			Field3406 complex64
			Field3407 complex64
		}{}), rune(0))]])+(1)])+(1)])])))) <- uintptr(0)
		defer recover()
		((func(interface{}, float32, func(uintptr, int16, interface{}) (int16, rune, rune), []int16) (struct{}, string))(nil))(interface{}(nil), float32(1.0), ((func(uintptr, int16, interface{}) (int16, rune, rune))(nil)), []int16{})
		Var3559 := [0][0]*[1]int{}
		Var3916 := [1]int{}
		Var3783 := (*int)(nil)
		Var3428 := [0]*int{}
		if false {
			select {
			case make(chan interface{}) <- interface{}(nil):
				_, Var3424 := complex64(1i), interface {
					Method3413(byte, string) (complex64, []complex128, error)
					Method3414(complex128, uint, func(error, error, uintptr) (float32, rune), *int16) uint
					Method3415(map[uintptr]uint, interface{}) (func(interface{}) (bool, bool), uintptr, [1]float32, func(byte, rune) (int16, interface{}))
					Method3416(map[uint]rune) (byte, int16, int)
					Method3417(interface {
						Method3418(bool, byte, uintptr) (int16, uint, int16)
					}) []float64
					Method3419(chan complex128, chan rune, uint, struct{}) (complex128, struct {
						Field3420 error
					}, complex64)
					Method3421(interface{}, []int, rune) (int, map[error]complex64, chan uint)
					Method3422(map[interface{}]int16, chan string) int
					Method3423(float32) float64
				}(nil)
				(*((Var3428)[(*(([]*int{})[(int)((*(*(*(([]***float64{})[((func(chan interface{}, string) int)(nil))(make(chan interface{}), "foo")])))))]))-(1)]))++
				switch {
				default:
				}
				_ = Var3424
			case (*((*(([]*[1]*[1]struct {
				Field3429 uint
				Field3430 uint
				Field3431 uint
				Field3432 interface{}
			}{})[((func(complex128, int16) int)(nil))(1i, int16(1))]))[((*(((Var3559)[(<-make(chan int, 1))])[(((([][2][1]int{})[(int)(Var3577)])[(*((*(Var3673))[((*(([]*struct {
				Field3703 complex64
				Field3704 bool
				Field3705 chan uint
				Field3706 int
			}{})[(*((([][1]*int{})[(int)((*(*(([]**[2]float32{})[(*(Var3783))-(1)])))[(Var3195)+(1)])])[(int)(([]uintptr{})[(*(*(([]**int{})[(int)((len)(([]string{})[((Var3916)[Var3195])-(1)]))])))+(1)])]))+(1)])).Field3706)-(1)]))+(1)])[(struct {
				Field4041 func(uintptr, float32) (complex64, uintptr, error)
				Field4042 struct{}
				Field4043 *uintptr
				Field4044 uintptr
				Field4045 int
				Field4046 interface{}
				Field4047 float64
				Field4048 interface{}
				Field4049 uint
				Field4050 []uint
			}{}).Field4045])+(1)]))[(int)(Var3195)])+(1)]))[((func(rune, int16, interface {
				Method4051(complex64, byte) chan complex128
			}) int)(nil))(rune(0), int16(1), interface {
				Method4051(complex64, byte) chan complex128
			}(nil))] = <-make(chan struct {
				Field3429 uint
				Field3430 uint
				Field3431 uint
				Field3432 interface{}
			}):
			case Var4052 := <-make(chan func(chan complex128, uint, complex64, complex64) (rune, func(interface{}, float32) (int16, bool)), 1):
				_ = Var4052
			case make(chan chan []error) <- make(chan []error, 1):
			}
		} else {
		}
		_ = Var3559
		_ = Var3916
		_ = Var3783
		_ = Var3428
		_ = Param2751
		_ = Param2752
		_ = Param2753
		_ = Param2754
		return [1]int{}
	}(make(chan interface {
		Method2749(error, complex64, uint, bool) (float64, complex128, rune, bool)
		Method2750(rune, error, complex128) (rune, float64, rune, uint)
	}, 1), uint(1), rune(0), (*rune)(nil)))[(Var4053)[(*((*((*((Var4054)[((func(uintptr, struct {
		Field4055 uint
	}, int16, rune) int)(nil))(uintptr(0), (struct {
		Field4055 uint
	}{}), int16(1), rune(0))]))[(struct {
		Field4113 int
	}{}).Field4113]))[(int)((len)(Var4114))]))[((func(rune, map[struct {
		Field4115 interface{}
	}]interface{}, interface {
		Method4116(map[error]byte, chan uintptr, byte) (bool, string, map[uint]int16, int)
		Method4117([]uint, uintptr, byte, float32) (func(interface{}, bool, string, int) (int, string), *uintptr, float32)
	}, int) int)(nil))(rune(0), make(map[struct {
		Field4115 interface{}
	}]interface{}, 1), interface {
		Method4116(map[error]byte, chan uintptr, byte) (bool, string, map[uint]int16, int)
		Method4117([]uint, uintptr, byte, float32) (func(interface{}, bool, string, int) (int, string), *uintptr, float32)
	}(nil), 1)]]]
}(float32(1.0), (struct{}{}), 1i)]))((struct{}{})), 1: 1}
var Var2745 = byte(0)
var Var2852 = (Var2933)[(<-make(chan int, 1))]
var Var2933 = [2][]**chan chan uintptr{([]**chan chan uintptr{})[(*(*((*(*(*((*(Var3091))[(Var3195)+(1)]))))[(int)(([]float32{})[(int)(([]byte{})[((func(uintptr, interface{}, chan interface{}, uintptr) int)(nil))(uintptr(0), interface{}(nil), make(chan interface{}, 1), uintptr(0))])])]))).Field2966:(*((*(([]*[1]*int{})[((([]struct {
	Field3252 int
}{})[(<-make(chan int))]).Field3252)-(1)]))[((func(error) int)(nil))(error(nil))])):([]int{})[(Var3195)+(1)]], []**chan chan uintptr{}}
var Var3091 = (<-([]chan func(chan error, uintptr, string, byte) func(rune) *[1]***[]**struct {
	Field2966 int
}{})[(struct {
	Field3099 int
}{}).Field3099])(Var3100, uintptr(0), "foo", byte(0))(rune(0))
var Var3100 = ((func(interface{}, bool, int) chan error)(nil))(interface{}(nil), false, 1)
var Var3195 = 1
var Var3255 = [0][0]int{}
var Var3341 = [2]*string{}
var Var3402 = [0]int{}
var Var3577 = int16(1)
var Var3673 = (*[2]*int)(nil)
var Var4053 = [1]int{}
var Var4054 = [2]*[0]*[0]*[2]int{}
var Var4114 = "foo"
var Var4287 = (*int)(nil)
var Var4348 = (*struct {
	Field4347 int
})(nil)

var Var2658 = "foo"
var Var2106 = [1]chan float64{}
var Var1975 = 1.0
var Var1970 = 1
var Var1937 = []chan chan int{}
var Var1723 = (*[0]uint)(nil)
var Var1612 = [1]rune{}
var Var167 = [1]float64{}