Skip to content

Instantly share code, notes, and snippets.

@ALTree

ALTree/crash.go

Created August 7, 2023 18:02
Show Gist options
  • Save ALTree/9f35f46b942f4e4b70a6c2750fd403e9 to your computer and use it in GitHub Desktop.
Save ALTree/9f35f46b942f4e4b70a6c2750fd403e9 to your computer and use it in GitHub Desktop.
Download ZIP
loong64 crash reproducer
Raw
crash.go
package main
import (
"math"
"reflect"
"strings"
"sync/atomic"
"unsafe"
)
type I0 interface{ *int8 | ~[]int }
var i int
var V1 map[rune]int64 = map[rune]int64{'\u52a5': int64(67)}
var V2 *struct {
St0 struct {
Ah0 []float32
}
} = nil
var V3 int16 = 0
var V4 int32 = 0
var V5 map[uint32]*rune = map[uint32]*rune{+(atomic.SwapUint32(nil, atomic.SwapUint32(nil, uint32(67))) & atomic.SwapUint32(nil, uint32(48)) << atomic.SwapUint32(nil, uint32(57))): nil}
var V6 func([]*float64, struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}, ...[]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}) struct {
St0 struct {
St0 struct {
H0 float32
I8_1 int8
}
}
} = nil
func F[G0 I0]() (uint32, int64, any, int16) {
var g0_0 G0
var am0, am1 []map[complex128]map[uint64]complex128
var ast0 []struct {
F0 float64
H1 float32
}
var by0 byte
make(chan int) <- min(int(int16(49)), len(""+strings.Join([]string{"", ""}, "")+min(strings.Join(make([]string, 50&^int(i)%i), unsafe.String(nil, 48)), unsafe.String(nil, 40), string([]byte("X")))+(unsafe.String(unsafe.StringData("xVh74OrpU"), i)+unsafe.String(nil, 54))), int(V3), ^(-+(19|copy(make([]any, 93), []any{any(17), any(96)}))*copy([]byte("yLvOb3zLaNgDn"+"EbWc"), strings.Join([]string{"tE8wTCDKwntjBZCc"}, "TIKjzaoiiphDY5J3G7fUmK")) | i))
go V6(append([]*float64{nil, nil}, nil), struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, any(69), append([]uint32{uint32(49)}, uint32(92)), append([][]int32{}, make([]int32, 12-copy(func(int64) [][]int64 {
V2 = V2
return [][]int64{}
}(V1[rune('N')]), append(append(make([][]int64, i), make([]int64, ^(83+int(i)-i)*int(i))), append(append(make([]int64, func([]map[rune]struct {
}, map[float32]chan []*string) int {
V5 = make(map[uint32]*rune, 40)
return len("W")
}([]map[rune]struct {
}{map[rune]struct {
}{-'T': struct {
}{}}, map[rune]struct {
}{*V5[uint32(57)]: struct {
}{}}}, map[float32]chan []*string{-float32(8935.8): make(chan []*string)})&copy([][]chan map[float64][]int64{make([]chan map[float64][]int64, 93), []chan map[float64][]int64{}}, append([][]chan map[float64][]int64{[]chan map[float64][]int64{}}, []chan map[float64][]int64{make(chan map[float64][]int64), make(chan map[float64][]int64)}))), V1['\u7592'^'E']), []int64{V1[^'\x9b']}...)))))}, []func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{99: nil})
{
var ch0, ch1 chan struct {
}
var ch2, ch3, ch4 chan chan **int64
var m2 map[complex128]int32
var ch5, ch6 chan func() bool
var papau64_0 *[]*[]uint64
var st0, st1 struct {
Ai64_0 []int64
St1 struct {
St0 struct {
R0 rune
M1 map[int64]float32
}
S1 string
}
U2 uint
}
var m3 map[uint32]map[uint64]chan struct {
F0 float64
}
var u0, u1 uint
m2 = m2
defer func(uint32) G0 {
V6 = V6
return func(map[int16]map[int32]uint, struct {
St0 struct {
St0 struct {
M0 map[string]uint
}
Aau1 [][]uint
M2 map[float32]struct {
By0 byte
R1 rune
I8_2 int8
I3 int
}
U64_3 uint64
}
St1 struct {
R0 rune
Fnc1 func([]float64, uintptr) chan float32
Ch2 chan []rune
}
Fnc2 func(complex128, chan any, []*string, func(string) []int16, float32) []struct {
}
I16_3 int16
}) G0 {
i = + +- -^8 / copy(make([]byte, 27^int(i)), strings.TrimFunc("", nil))
return func() G0 {
recover()
ch0 = ch1
return g0_0
}()
}(map[int16]map[int32]uint{+ +(-(V3 | V3) << V3): func(uint) map[int32]uint {
u0 = uint(uint64(22))
return make(map[int32]uint, copy(append([]*map[uint64]any{}, []*map[uint64]any{nil, nil}...), append([]*map[uint64]any{nil, nil}, append([]*map[uint64]any{61: nil}, nil)...))%int(i))
}(uint(0))}, struct {
St0 struct {
St0 struct {
M0 map[string]uint
}
Aau1 [][]uint
M2 map[float32]struct {
By0 byte
R1 rune
I8_2 int8
I3 int
}
U64_3 uint64
}
St1 struct {
R0 rune
Fnc1 func([]float64, uintptr) chan float32
Ch2 chan []rune
}
Fnc2 func(complex128, chan any, []*string, func(string) []int16, float32) []struct {
}
I16_3 int16
}{struct {
St0 struct {
M0 map[string]uint
}
Aau1 [][]uint
M2 map[float32]struct {
By0 byte
R1 rune
I8_2 int8
I3 int
}
U64_3 uint64
}{struct {
M0 map[string]uint
}{map[string]uint{"otzzsdEHfTDbXaz": +(uint(35) * st1.U2) & u1}}, make([][]uint, 31^i), map[float32]struct {
By0 byte
R1 rune
I8_2 int8
I3 int
}{(*V2).St0.Ah0[96] + (*V2).St0.Ah0[69]: struct {
By0 byte
R1 rune
I8_2 int8
I3 int
}{byte(97), st1.St1.St0.R0, int8(61) &^ int8(i), -len("pDZ1d") * copy([]func(uintptr, G0, func(struct {
I64_0 int64
Pan1 *any
}, ...*[]uint32) int32, struct {
St0 struct {
Aup0 []uintptr
Ai32_1 []int32
}
}, int8, int, byte) int{nil, nil}, make([]func(uintptr, G0, func(struct {
I64_0 int64
Pan1 *any
}, ...*[]uint32) int32, struct {
St0 struct {
Aup0 []uintptr
Ai32_1 []int32
}
}, int8, int, byte) int, 79&^i&copy([]int32{int32(67), int32(72), int32(3)}, []int32{15: int32(72)})))}}, func() uint64 {
ch1 = make(chan struct {
})
return +(uint64(22) + atomic.AddUint64(nil, uint64(82))) | atomic.AddUint64(nil, atomic.LoadUint64(nil))
}() & (*(*papau64_0)[len(append(make([]*[][]byte, 37), nil))])[90]}, struct {
R0 rune
Fnc1 func([]float64, uintptr) chan float32
Ch2 chan []rune
}{'\u65ae', nil, func() chan []rune {
m2 = m2
return make(chan []rune)
}()}, nil, V3})
}(atomic.SwapUint32(nil, atomic.SwapUint32(nil, uint32(83))))
{
var an0, an1 any
var i8_0, i8_1 int8
var s0, s1 string
var c0 complex128
var ch7 chan func(*struct {
I8_0 int8
}, uint, rune) any
var ps0, ps1 *string
lab6:
for u0 != st1.U2 {
var fnc1 func(byte, map[uint32][]struct {
F0 float64
I8_1 int8
}, byte, *byte) map[uint32]map[bool][]uintptr = func(p0 byte, p1 map[uint32][]struct {
F0 float64
I8_1 int8
}, p2 byte, p3 *byte) map[uint32]map[bool][]uintptr {
i8_1 = -(+ +(^i8_1 + i8_0) &^ i8_0)
i8_1 = int8(st0.U2) - p1[uint32(35)][copy([]func(uint64, **struct {
}, G0, map[rune]struct {
Ai32_0 []int32
St1 struct {
I64_0 int64
U32_1 uint32
}
Fnc2 func() rune
}, struct {
I32_0 int32
St1 struct {
An0 any
R1 rune
}
}, ...byte) struct {
Up0 uintptr
Pf1 *float64
Ast2 []struct {
By0 byte
}
}{0: nil}, append([]func(uint64, **struct {
}, G0, map[rune]struct {
Ai32_0 []int32
St1 struct {
I64_0 int64
U32_1 uint32
}
Fnc2 func() rune
}, struct {
I32_0 int32
St1 struct {
An0 any
R1 rune
}
}, ...byte) struct {
Up0 uintptr
Pf1 *float64
Ast2 []struct {
By0 byte
}
}{nil, nil}, func() func(uint64, **struct {
}, G0, map[rune]struct {
Ai32_0 []int32
St1 struct {
I64_0 int64
U32_1 uint32
}
Fnc2 func() rune
}, struct {
I32_0 int32
St1 struct {
An0 any
R1 rune
}
}, ...byte) struct {
Up0 uintptr
Pf1 *float64
Ast2 []struct {
By0 byte
}
} {
p0 = byte(int8(47))
return nil
}()))].I8_1
ch4 = make(chan chan **int64)
return make(map[uint32]map[bool][]uintptr, ^^((i|copy(func([]map[rune]G0, string, struct {
St0 struct {
St0 struct {
I64_0 int64
An1 any
}
I8_1 int8
Au32_2 []uint32
}
An1 any
B2 bool
Ast3 []struct {
Pb0 *bool
}
}) [][][][][]string {
ps1 = ps1
return make([][][][][]string, 27)
}([]map[rune]G0{make(map[rune]G0, 76)}, "1g5H3VZ4SPM6yZ1epz", struct {
St0 struct {
St0 struct {
I64_0 int64
An1 any
}
I8_1 int8
Au32_2 []uint32
}
An1 any
B2 bool
Ast3 []struct {
Pb0 *bool
}
}{struct {
St0 struct {
I64_0 int64
An1 any
}
I8_1 int8
Au32_2 []uint32
}{struct {
I64_0 int64
An1 any
}{int64(98), any(66)}, int8(92), make([]uint32, 80)}, any(35), true, []struct {
Pb0 *bool
}{86: struct {
Pb0 *bool
}{nil}}}), make([][][][][]string, 58)))&i)^copy([]map[rune]G0{}, make([]map[rune]G0, ^len(func(func(struct {
F0 float64
}, uint) chan int32, []struct {
}) []map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
} {
p0 = byte(47) + p0
return append([]map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
}{map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
}{6169.57i: make(chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
})}, map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
}{3464.44i: make(chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
})}, map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
}{4569.37i: make(chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
})}}, map[complex128]chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
}{7036.39i: make(chan struct {
Aup0 []uintptr
H1 float32
Up2 uintptr
U64_3 uint64
})})
}(nil, make([]struct {
}, len([]map[rune]string{44: make(map[rune]string, 55)})%int(i))))%i)))
}
var pam0, pam1, pam2 *[]map[int]uint64
var ppr0, ppr1, ppr2 **rune
var ch8, ch9 chan *string
V6 = V6
m3[atomic.AddUint32(nil, atomic.LoadUint32(nil))/atomic.LoadUint32(nil)] = map[uint64]chan struct {
F0 float64
}{+(+uint64(67) + atomic.LoadUint64(nil) - atomic.AddUint64(nil, uint64(66))): make(chan struct {
F0 float64
})}
ch3 = make(chan chan **int64)
V1[+(-func() rune {
ch0 = ch0
return '\u50ce' - '\x91' | ('L' + 'Q') + -*V5[uint32(65)]
}() | (+('\u8823'+'H'-'\u126f'&'\xa5') + +(('\u6e5c'|'\xd6')>>u1))&-^-'L')] = ^**<-<-ch3 &^ **<-<-ch4
st1 = struct {
Ai64_0 []int64
St1 struct {
St0 struct {
R0 rune
M1 map[int64]float32
}
S1 string
}
U2 uint
}{st0.Ai64_0, st1.St1, uint(79)&st0.U2 + u1 ^ st1.U2}
ps0 = &s1
ch1 = make(chan struct {
})
papau64_0 = papau64_0
_, _, _, _, _, _, _, _, _ = fnc1, pam0, pam1, pam2, ppr0, ppr1, ppr2, ch8, ch9
continue lab6
}
m3[+(atomic.SwapUint32(nil, atomic.LoadUint32(nil)) % atomic.AddUint32(nil, atomic.SwapUint32(nil, atomic.LoadUint32(nil))))] = func(any) map[uint64]chan struct {
F0 float64
} {
V4 = ^int32(V3)
return m3[uint32(byte(11))]
}((<-ch7)(nil, st1.U2, '\ub374'))
close(ch3)
switch complex128(4356.52i) {
case -c0 + +- -3137.71i*(am0[len(st1.St1.S1+unsafe.String(nil, 42))][4221.82i][atomic.AddUint64(nil, uint64(52))]-am1[len(append(append([]func([]byte, struct {
B0 bool
St1 struct {
Fnc0 func() any
I8_1 int8
}
U32_2 uint32
}, map[int64]struct {
Pi0 *int
By1 byte
G0_2 G0
}) uint32{nil, nil}, []func([]byte, struct {
B0 bool
St1 struct {
Fnc0 func() any
I8_1 int8
}
U32_2 uint32
}, map[int64]struct {
Pi0 *int
By1 byte
G0_2 G0
}) uint32{nil, nil, nil, nil}...), nil))][-complex128(9853.12i)][uint64(13)>>u1]):
var aan0 []any
var st2, st3, st4 struct {
}
var ppst0, ppst1, ppst2 **struct {
}
var pch0, pch1 *chan struct {
S0 string
U1 uint
Aan2 []any
}
var pu32_0, pu32_1 *uint32
var u32_0 uint32
am1[+i|i^int(i)] = am1[copy([]G0{g0_0, g0_0, g0_0}, []G0{})]
i = -int(**<-<-ch3)
ch7 = make(chan func(*struct {
I8_0 int8
}, uint, rune) any)
st4 = struct {
}{}
st3 = struct {
}{}
g0_0 = g0_0
c0 = -(-(7373.84i + am0[44][1135.50i][uint64(97)]) - func(**int16) complex128 {
i = +int(u32_0)
return (-1084.06i + (9023.79i + 9537.27i)) * -(2864.98i * 3102.27i)
}(nil)) - (am1[copy(func() []map[uint32]*struct {
} {
st2 = struct {
}{}
return make([]map[uint32]*struct {
}, ^len("v6O00Y7MTFHnxeVAyBGcj")^int(i))
}(), append([]map[uint32]*struct {
}{65: map[uint32]*struct {
}{uint32(29) >> st0.U2: &st2}}, make(map[uint32]*struct {
}, len([]func() *[]struct {
Up0 uintptr
Up1 uintptr
}{26: nil})*copy(append(make([]map[int]func(int, func(struct {
}) int32, struct {
B0 bool
}, chan []int16) *map[uint]bool, 89), map[int]func(int, func(struct {
}) int32, struct {
B0 bool
}, chan []int16) *map[uint]bool{29: nil}), append([]map[int]func(int, func(struct {
}) int32, struct {
B0 bool
}, chan []int16) *map[uint]bool{69: map[int]func(int, func(struct {
}) int32, struct {
B0 bool
}, chan []int16) *map[uint]bool{61: nil}}, make([]map[int]func(int, func(struct {
}) int32, struct {
B0 bool
}, chan []int16) *map[uint]bool, 19)...)))))][+-(1396.34i + 9008.90i)][uint64(58)] + am1[len(strings.TrimFunc(s0, nil))][3322.38i][+ +uint64(39)])
ppst0 = ppst0
_, _, _, _, _, _, _, _, _, _, _, _ = aan0, st2, st3, st4, ppst0, ppst1, ppst2, pch0, pch1, pu32_0, pu32_1, u32_0
default:
var fnc1 func(float64, *map[uintptr]chan bool, byte, *[][]uint) chan uint64 = func(p0 float64, p1 *map[uintptr]chan bool, p2 byte, p3 *[][]uint) chan uint64 {
st0 = struct {
Ai64_0 []int64
St1 struct {
St0 struct {
R0 rune
M1 map[int64]float32
}
S1 string
}
U2 uint
}{st0.Ai64_0, st1.St1, uint(st0.U2)}
m3 = m3
return func(uint64) chan uint64 {
ch1 = ch0
return make(chan uint64)
}(atomic.SwapUint64(nil, atomic.AddUint64(nil, atomic.SwapUint64(nil, atomic.AddUint64(nil, uint64(44))))))
}
var c1, c2, c3 complex128
var up0, up1, up2 uintptr
var st2 struct {
}
var pst1, pst2 *struct {
Ch0 chan func(int16, any, uint32, rune, ...string) bool
I32_1 int32
Pb2 *bool
}
ch3 = ch4
V5 = V5
c0 = complex128(c0)
s1 = st1.St1.S1
fnc1 = fnc1
c2 = -+-(c0 + am1[min(0, i)%copy([]byte{}, "sWSlqaNhobkV21X7i")][am0[61][9861.82i][uint64(51)]][uint64(25)])
ch6 = ch5
by0 = + +(+byte(i8_0) | by0)
_, _, _, _, _, _, _, _, _, _ = fnc1, c1, c2, c3, up0, up1, up2, st2, pst1, pst2
}
go func(int8) complex128 {
am1[len(make([]func(int32) []func(struct {
I0 int
}, []complex128, *int, float64, struct {
}, map[int32]int) uint32, i))] = func(float32, float32) map[complex128]map[uint64]complex128 {
recover()
ch2 = make(chan chan **int64)
return am1[len(strings.TrimFunc(st1.St1.S1, nil)+"CQygTFUrbS")]
}(float32(5999.6), (*V2).St0.Ah0[len([]*[]float32{nil})])
return c0 * 5206.53i
}(int8(40))
clear(V5)
defer V6([]*float64{nil}, struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, (<-ch7)(nil, st1.U2, rune(st1.St1.St0.R0)), func(*[]*map[byte]float64, func([]byte, int16, []uint64, struct {
U0 uint
}, struct {
Pst0 *struct {
I32_0 int32
}
Fnc1 func([]int, []uint) chan bool
Ach2 []chan uint
}) int64) []uint32 {
V2 = V2
return []uint32{71: atomic.LoadUint32(nil)}
}(nil, nil), [][]int32{23: []int32{V4}}}, make([]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}, len([][]bool{})*copy([][]struct {
I64_0 int64
}{make([]struct {
I64_0 int64
}, len(st0.St1.S1)), []struct {
I64_0 int64
}{struct {
I64_0 int64
}{int64(75)}, struct {
I64_0 int64
}{int64(8)}, struct {
I64_0 int64
}{-V1[^('6' ^ '\u859b')]}}}, func(byte) [][]struct {
I64_0 int64
} {
ps0 = ps0
return func() [][]struct {
I64_0 int64
} {
u0 = uint(int8(54)) &^ u1
return make([][]struct {
I64_0 int64
}, len("L33hpH5lS3ms1XT"+("6sIP"+"7jjK47032I67gnubRqYSwjdW3w"))*int(i))
}()
}(byte(3)))))
defer V6([]*float64{2: nil}, struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{ps0, (<-ch7)(nil, st1.U2, ('\xcc'|'\xa2'^+'1')&^('\u6221'+':'|^'\x1a')), make([]uint32, (^(+24/i)|i)&int(i)-copy([]struct {
}{89: <-ch1}, make([]struct {
}, ^int(by0)%copy(append([]func(bool, []map[int]struct {
I8_0 int8
}, map[int16]map[string]*string, float32, float32, chan struct {
Pup0 *uintptr
B1 bool
M2 map[int16]byte
}) int64{30: func() func(bool, []map[int]struct {
I8_0 int8
}, map[int16]map[string]*string, float32, float32, chan struct {
Pup0 *uintptr
B1 bool
M2 map[int16]byte
}) int64 {
ch6 = func(*any, []struct {
Up0 uintptr
St1 struct {
}
}, []uint) chan func() bool {
papau64_0 = unsafe.SliceData([][]*[]uint64{[]*[]uint64{nil, nil}})
return make(chan func() bool)
}(nil, []struct {
Up0 uintptr
St1 struct {
}
}{struct {
Up0 uintptr
St1 struct {
}
}{uintptr(20), struct {
}{}}}, []uint{uint(33), uint(45), uint(20)})
return nil
}()}, make([]func(bool, []map[int]struct {
I8_0 int8
}, map[int16]map[string]*string, float32, float32, chan struct {
Pup0 *uintptr
B1 bool
M2 map[int16]byte
}) int64, i&^int(i))...), []func(bool, []map[int]struct {
I8_0 int8
}, map[int16]map[string]*string, float32, float32, chan struct {
Pup0 *uintptr
B1 bool
M2 map[int16]byte
}) int64{nil, nil})))), [][]int32{append([]int32{func() int32 {
papau64_0 = papau64_0
return +m2[5437.23i]
}(), int32(V3), V4 >> st0.U2}, []int32{int32(st1.Ai64_0[61])}...), make([]int32, (i%int(i)-copy(make([]map[int64]int8, 91&^copy(append([][]struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{make([]struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}, 27)}, []struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{57: struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{uintptr(44), []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{uint32(85), true, uint32(48)}, struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{uint32(5), true, uint32(92)}}, map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}{int32(79): struct {
Up0 uintptr
H1 float32
I16_2 int16
}{uintptr(93), float32(7032.2), int16(69)}}}}), [][]struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{[]struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{uintptr(91), make([]struct {
U32_0 uint32
B1 bool
U32_2 uint32
}, 67), map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}{int32(6): struct {
Up0 uintptr
H1 float32
I16_2 int16
}{uintptr(87), float32(7301.8), int16(70)}}}, struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{uintptr(63), []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{56: struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{uint32(21), true, uint32(61)}}, make(map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}, 97)}, struct {
Up0 uintptr
Ast1 []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}
M2 map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}
}{uintptr(98), []struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{5: struct {
U32_0 uint32
B1 bool
U32_2 uint32
}{uint32(79), true, uint32(59)}}, map[int32]struct {
Up0 uintptr
H1 float32
I16_2 int16
}{int32(77): struct {
Up0 uintptr
H1 float32
I16_2 int16
}{uintptr(43), float32(5109.7), int16(7)}}}}})), make([]map[int64]int8, 29)))&copy(func(struct {
S0 string
St1 struct {
I8_0 int8
S1 string
Pch2 *chan byte
}
}, struct {
Ah0 []float32
}) []byte {
ps1 = func(int8, float64) *string {
ch0 = make(chan struct {
})
return ps0
}(i8_1, math.Sqrt(9111.3))
return []byte{by0}
}(struct {
S0 string
St1 struct {
I8_0 int8
S1 string
Pch2 *chan byte
}
}{*&s1, struct {
I8_0 int8
S1 string
Pch2 *chan byte
}{i8_1, string([]byte{byte(58)}), nil}}, (*V2).St0), *ps1)), append(make([]int32, int(V3)+int(i)^i), []int32{76: int32(atomic.AddUint32(nil, uint32(44))) / m2[518.12i+3206.35i]}...)}}, func(rune) []func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
} {
g0_0 = g0_0
return make([]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}, ^(-i/int(i)%i-int(i))-i)
}(*V5[uint32(uint(93))]))
_, _, _, _, _, _, _, _, _, _ = an0, an1, i8_0, i8_1, s0, s1, c0, ch7, ps0, ps1
}
st1.St1 = struct {
St0 struct {
R0 rune
M1 map[int64]float32
}
S1 string
}{struct {
R0 rune
M1 map[int64]float32
}{+func(func(map[float64]struct {
M0 map[rune]float32
}, *[]*float64, []uintptr, []float32, ...float64) map[uint]uintptr, *[]struct {
U0 uint
St1 struct {
}
}, complex128, *struct {
Ppby0 **byte
Pc1 *complex128
}) rune {
st1.Ai64_0 = append(st0.Ai64_0, make([]int64, int(int16(83))-i)...)
return '\uc9df'
}(nil, nil, 6123.57i, nil) - func([]float64) rune {
am1[7] = am0[69]
return +'\xad'&^('\xc8'+'\xd4') - ^func(**uintptr) rune {
u1 = uint(22) >> u1
return '@'
}(nil)
}([]float64{(<-m3[uint32(int8(63))][13]).F0 + (<-m3[+uint32(47)][uint64(63)]).F0}), st0.St1.St0.M1}, strings.TrimFunc(st1.St1.S1, nil)}
V1[rune('0')] = **<-<-ch2 % **<-<-ch3
m2[-(9299.51i - am0[i][0][88])] = 0
_, _, _, _, _, _, _, _, _, _, _, _, _, _ = ch0, ch1, ch2, ch3, ch4, m2, ch5, ch6, papau64_0, st0, st1, m3, u0, u1
}
var ast1, ast2 []struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}
var by1, by2 byte
var aai0, aai1 [][]int
var st0, st1 struct {
C0 complex128
G0_1 G0
}
var st2 struct {
St0 struct {
}
Fnc1 func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune
}
V2 = V2
am0 = am1[4:20]
select {
case <-make(chan int32):
switch "y" + strings.TrimFunc(strings.TrimFunc("Q", nil), nil) + (max(func([]uint64, uint) string {
by2 = +by0
return max(strings.TrimFunc(unsafe.String(nil, 23), nil), max("4", *ast1[2].Ps0, "g2KUnInaODjTVdzs"+"d0G3"))
}([]uint64{82: atomic.SwapUint64(nil, atomic.AddUint64(nil, uint64(76)))}, uint(19)), strings.Join([]string{67: strings.Join(make([]string, 59), "ILN3yeVSvRCFaNEEBIHP4")}, strings.TrimFunc("QSGP9NzfQau8Yy4rX", nil)), string([]byte(*ast1[94].Ps0))) + min("V"+strings.TrimFunc(unsafe.String(nil, 17), nil), unsafe.String(unsafe.StringData(unsafe.String(unsafe.StringData("rGtRJ5ooqV"), aai0[84][91])), len(max("KqlPcD3ezuuqQRTIP", unsafe.String(nil, 31)))), string(make([]byte, -+aai0[46][85]-int(i))))) {
case unsafe.String(unsafe.StringData(strings.Join([]string{"" + ("FCrZOZO" + "G"), strings.TrimFunc("lR2VxiQxAXAPeDt", nil) + strings.TrimFunc("ycjRTUBVei7OoIx6S7aYYBf46", nil)}, "NY3FlRt8Y")), copy(append([]map[string]*complex128{map[string]*complex128{max("a", "eEV") + ("a" + "a"): nil}, func() map[string]*complex128 {
V6 = nil
return map[string]*complex128{strings.Join(make([]string, 7), "a"): nil}
}()}, map[string]*complex128{"E": nil}), append(append(make([]map[string]*complex128, ^30*aai0[43][1]), []map[string]*complex128{map[string]*complex128{"R7FN": nil}}...), map[string]*complex128{strings.TrimFunc("X8XoqDwSsLx9", nil): nil}))) + unsafe.String(nil, aai1[aai0[aai1[83][54]][i]|copy([]uint{uint(39)}, append(func(map[int]float64, struct {
Pi64_0 *int64
C1 complex128
}, chan []chan map[uint]string, map[int8]int8) []uint {
V1['D'] = +int64(98)
return []uint{uint(33), uint(64)}
}(map[int]float64{16: 495.6}, struct {
Pi64_0 *int64
C1 complex128
}{nil, 2348.97i}, make(chan []chan map[uint]string), map[int8]int8{int8(18): int8(77)}), []uint{uint(24)}...))][int(atomic.LoadUint32(nil))&^aai1[copy(make([][]struct {
G0_0 G0
}, 62), [][]struct {
G0_0 G0
}{make([]struct {
G0_0 G0
}, 24), []struct {
G0_0 G0
}{98: struct {
G0_0 G0
}{g0_0}}})][96]]):
var by3, by4, by5 byte
var paup0 *[]uintptr
var i8_0, i8_1 int8
var ach0, ach1 []chan float64
var m2 map[float64]func(map[uintptr]struct {
S0 string
R1 rune
I16_2 int16
B3 bool
}, map[uint32][]int8, *map[float32]rune, string, struct {
Pb0 *bool
Aup1 []uintptr
}, int16, bool) []uintptr
var pby0 *byte
var aup0 []uintptr
V4 = ^int32(32)
g0_0 = g0_0
g0_0 = func(bool) G0 {
ach0 = func(struct {
I16_0 int16
}, uintptr) []chan float64 {
paup0 = paup0
return []chan float64{25: ach1[i]}
}(struct {
I16_0 int16
}{func(G0, *func(struct {
H0 float32
Ai64_1 []int64
}) uint) int16 {
V6 = nil
return int16(36)
}(g0_0, nil)}, atomic.LoadUintptr(nil))
return g0_0
}(false)
aai1 = make([][]int, -(77&^copy(append(make([][][]map[complex128]uint64, (67^aai0[60][56])/copy([]byte{23: byte(81)}, "xhpl6Pb751SVccb")), [][]map[complex128]uint64{make([]map[complex128]uint64, 54), []map[complex128]uint64{map[complex128]uint64{7284.17i: uint64(6)}, make(map[complex128]uint64, 66), map[complex128]uint64{4535.00i: uint64(57)}}}), [][][]map[complex128]uint64{[][]map[complex128]uint64{func(map[int16]***uint64, G0) []map[complex128]uint64 {
V1 = map[rune]int64{'\x5c': int64(39)}
return make([]map[complex128]uint64, 32)
}(map[int16]***uint64{int16(38): nil}, g0_0)}, make([][]map[complex128]uint64, aai0[^66+aai1[6][22]][7])}))&int(i))
V5[uint32(77)+ast2[aai1[copy(append([][]map[int32]map[int]map[byte]int{make([]map[int32]map[int]map[byte]int, 96), make([]map[int32]map[int]map[byte]int, -33*aai1[46][37])}, append(func(G0) []map[int32]map[int]map[byte]int {
by3 = byte(7) - by0
return []map[int32]map[int]map[byte]int{make(map[int32]map[int]map[byte]int, 54)}
}(g0_0), map[int32]map[int]map[byte]int{int32(67): map[int]map[byte]int{83: map[byte]int{byte(61): 23}}})), [][]map[int32]map[int]map[byte]int{21: []map[int32]map[int]map[byte]int{make(map[int32]map[int]map[byte]int, 62)}})][min(19^copy(make([]string, 73), []string{"yxBU41gpHvDk1H", "nvxRIc", "Mzap9K3xBTvm03xyLeayyBhd2cDg"}), 43, +6)/int(i)%copy(func(*int32) []uint32 {
ast2[20] = func(int8, uint) struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
} {
by3 = byte(39) - by0
return struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{nil, uint32(82), nil}
}(int8(46), uint(24))
return append([]uint32{uint32(30)}, []uint32{}...)
}(nil), make([]uint32, len([]bool{})))]].U32_1] = func() *rune {
aai1[34] = aai1[i]
return nil
}()
by1 = min(by0&^by5, byte(int64(14)))
i8_1 = +i8_1
st1 = struct {
C0 complex128
G0_1 G0
}{func(int32, struct {
Pst0 *struct {
B0 bool
}
}, []**int32) complex128 {
aai1 = make([][]int, -^(func(*[]*func(rune, complex128, uint64, complex128, uint, int16) float32, float32, []complex128) int {
st0.C0 = complex128(3551.82i)
return 87
}(nil, float32(6831.3), []complex128{6226.21i, 6495.73i})*i)|int(i)^aai1[79][func(struct {
F0 float64
C1 complex128
}) int {
aai1[46] = append([]int{43: 82}, 59*int(i))
return int(int64(22)) * int(i)
}(struct {
F0 float64
C1 complex128
}{2820.5 + math.Sqrt(9845.7) + math.Ldexp(1898.2, 18), func(byte, int64) complex128 {
i = int(uint64(65))
return -7554.20i
}(by4, V1['\uae13'])})&copy([]byte{+(byte(32) >> uint(i)), min(byte(27), byte(51), byte(68), byte(69)) | by1, *pby0}, "ZE6sMgSQaUKXRp")])
return complex128(st0.C0)
}(int32(8), struct {
Pst0 *struct {
B0 bool
}
}{nil}, []**int32{nil}), g0_0}
_, _, _, _, _, _, _, _, _, _, _ = by3, by4, by5, paup0, i8_0, i8_1, ach0, ach1, m2, pby0, aup0
default:
var i64_0, i64_1 int64
var i1 int
var pc0, pc1 *complex128
var by3, by4 byte
var ai8_0, ai8_1, ai8_2 []int8
var st3, st4 struct {
M0 map[uint64]struct {
I0 int
St1 struct {
B0 bool
}
G0_2 G0
I64_3 int64
}
}
var fnc1 func(*func() struct {
U32_0 uint32
}, **[]int64, int64, func(chan struct {
S0 string
I16_1 int16
Up2 uintptr
}, int8, int, int32, ...struct {
M0 map[float32]int64
Aby1 []byte
}) []float64, struct {
St0 struct {
M0 map[complex128]bool
M1 map[string]int
}
}, struct {
Pm0 *map[int32]G0
Ah1 []float32
Fnc2 func(*complex128, []int64, map[int32]uint, map[int]float64, struct {
}, map[bool]string, struct {
B0 bool
I8_1 int8
}) chan int8
}) *[][]bool = func(p0 *func() struct {
U32_0 uint32
}, p1 **[]int64, p2 int64, p3 func(chan struct {
S0 string
I16_1 int16
Up2 uintptr
}, int8, int, int32, ...struct {
M0 map[float32]int64
Aby1 []byte
}) []float64, p4 struct {
St0 struct {
M0 map[complex128]bool
M1 map[string]int
}
}, p5 struct {
Pm0 *map[int32]G0
Ah1 []float32
Fnc2 func(*complex128, []int64, map[int32]uint, map[int]float64, struct {
}, map[bool]string, struct {
B0 bool
I8_1 int8
}) chan int8
}) *[][]bool {
by1 = +byte(uint(40))
i64_1 = ^int64(60) * (**p1)[-40/p4.St0.M1["YeoXwFJraH"]*i&^i1]
aai1[^int(uint(69))&^st3.M0[min(+(atomic.SwapUint64(nil, uint64(56))<<atomic.AddUint64(nil, uint64(10)))>>uint(i), +(atomic.AddUint64(nil, uint64(0))&^atomic.LoadUint64(nil)-atomic.AddUint64(nil, uint64(20))))].I0] = append([]int{^int(ai8_0[st4.M0[uint64(36)].I0])}, copy(make([][]int32, 19), [][]int32{97: make([]int32, aai0[st4.M0[uint64(76)%atomic.AddUint64(nil, uint64(49))<<atomic.AddUint64(nil, uint64(9))].I0][p4.St0.M1["LHI0Ony3ySoGJUNVqN"]])}))
st0.G0_1 = g0_0
return nil
}
var ach0 []chan int32
by0 = by1>>uint(i) - by0
by0 = +byte(V3)
i = ^38
st2 = struct {
St0 struct {
}
Fnc1 func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune
}{st2.St0, func() func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune {
st1 = struct {
C0 complex128
G0_1 G0
}{-func(*[]int) complex128 {
ai8_1 = ai8_2
return -func(map[float64]byte) complex128 {
g0_0 = g0_0
return 947.24i * am1[88][3356.55i][uint64(46)]
}(make(map[float64]byte, (4-i)/int(i)-i1))
}(nil), g0_0}
return nil
}()}
st1.C0 = *pc1
st3 = struct {
M0 map[uint64]struct {
I0 int
St1 struct {
B0 bool
}
G0_2 G0
I64_3 int64
}
}{map[uint64]struct {
I0 int
St1 struct {
B0 bool
}
G0_2 G0
I64_3 int64
}{atomic.LoadUint64(nil): st4.M0[uint64(V3)>>uint(i1)]}}
st3.M0 = make(map[uint64]struct {
I0 int
St1 struct {
B0 bool
}
G0_2 G0
I64_3 int64
}, aai0[9][func(struct {
I32_0 int32
Pm1 *map[rune]func(float32, int8, int64, G0, ...uint) int
}, chan int) int {
by1 = max(byte(11), byte(81), byte(83)&by2, +byte(21))
return copy([]byte{byte(97)}, "XsMyo7YRUavntK3"+"mEFKb7S1tC")
}(struct {
I32_0 int32
Pm1 *map[rune]func(float32, int8, int64, G0, ...uint) int
}{^<-ach0[74], nil}, make(chan int))/int(i1)]/i-int(i))
st2.St0 = st2.St0
_, _, _, _, _, _, _, _, _, _, _, _, _, _ = i64_0, i64_1, i1, pc0, pc1, by3, by4, ai8_0, ai8_1, ai8_2, st3, st4, fnc1, ach0
}
if !(*ast2[62].Ps0 <= string([]byte{+byte(58), +((byte(79)*by1 ^ by1) &^ by0), max(func() byte {
aai1 = append(aai1, aai1[75])
return byte(59)
}(), by0)})) {
var pg0_0 *G0
var pb0, pb1 *bool
var pach0, pach1, pach2 *[]chan struct {
An0 any
U64_1 uint64
}
var ast3, ast4, ast5 []struct {
B0 bool
C1 complex128
Pst2 *struct {
By0 byte
}
}
var st3, st4 struct {
Pch0 *chan chan G0
U1 uint
}
var st5, st6, st7 struct {
Pf0 *float64
}
var pppf0, pppf1 ***float64
var papu32_0, papu32_1, papu32_2 *[]*uint32
st3 = struct {
Pch0 *chan chan G0
U1 uint
}{nil, uint(32)}
papu32_0 = unsafe.SliceData([][]*uint32{*papu32_1, *papu32_1, *papu32_0, append(make([]*uint32, int(V3)/int(i)), *papu32_2...)})
pb1 = unsafe.SliceData([]bool{!(+(*V2).St0.Ah0[60] > ast0[len("NTPOC8MQtd3K")].H1)})
papu32_1 = papu32_2
i = ^(copy(append(append(append(make([]func(*[]map[int32]int32, *[]int32, []*chan uint32, ...struct {
Pm0 *map[float64]complex128
By1 byte
}) map[int]string, 44), nil), nil), nil), append(append(make([]func(*[]map[int32]int32, *[]int32, []*chan uint32, ...struct {
Pm0 *map[float64]complex128
By1 byte
}) map[int]string, (int(int64(57))+copy([][]float64{make([]float64, 20), []float64{96: 3210.7}}, make([][]float64, 92)))&copy([]struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
}{struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
}{struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}{float32(7540.5), struct {
S0 string
M1 map[uintptr]int64
}{"kFq4rM3yzyfZ3W", make(map[uintptr]int64, 84)}}}}, func() []struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
} {
aai0[60] = make([]int, 49)
return []struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
}{struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
}{struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}{float32(6274.1), struct {
S0 string
M1 map[uintptr]int64
}{"eHcobkUGYZH7", map[uintptr]int64{uintptr(19): int64(11)}}}}, struct {
St0 struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}
}{struct {
H0 float32
St1 struct {
S0 string
M1 map[uintptr]int64
}
}{float32(6247.3), struct {
S0 string
M1 map[uintptr]int64
}{"UAZ", make(map[uintptr]int64, 23)}}}}
}())), nil), append(append([]func(*[]map[int32]int32, *[]int32, []*chan uint32, ...struct {
Pm0 *map[float64]complex128
By1 byte
}) map[int]string{26: nil}, nil), func(bool, *map[float64]rune, **func() *uint32, int16) func(*[]map[int32]int32, *[]int32, []*chan uint32, ...struct {
Pm0 *map[float64]complex128
By1 byte
}) map[int]string {
papu32_2 = papu32_1
return nil
}(*pb1, nil, nil, V3))...)) / copy([]chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8{5: make(chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8)}, []chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8{make(chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8), make(chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8), make(chan func(...func(bool, chan int8, uintptr, *int16, *string, map[uint]byte, ...struct {
C0 complex128
F1 float64
}) []int32) []*int8)}))
aai0 = append([][]int{3: aai1[+(23&^copy([]*G0{}, []*G0{50: nil})&^int(i))^aai1[76|i][i]]}, aai1[aai1[len(append(append([]map[float32]*chan struct {
}{map[float32]*chan struct {
}{float32(9527.4): nil}, map[float32]*chan struct {
}{float32(3845.1): nil}}, map[float32]*chan struct {
}{float32(8187.5): nil}), make(map[float32]*chan struct {
}, 43)))&^aai0[i][^37+i]][55]])
V5 = V5
V1[^func(map[rune][][]chan uint) rune {
am1[-(^(min(28)|aai1[55][90])|copy(make([]uint64, int(uint(27))|copy([]map[int8]map[float32]struct {
R0 rune
M1 map[float32]string
}{}, make([]map[int8]map[float32]struct {
R0 rune
M1 map[float32]string
}, 6))), append(append([]uint64{uint64(80)}, uint64(34)), []uint64{}...)))&^aai0[64][0]] = am1[15/aai0[55|aai1[83][6]|aai0[-19|aai1[87][7]][64]][-35&aai1[42][46]]]
return (func() rune {
papu32_0 = papu32_1
return *V5[uint32(34)%atomic.AddUint32(nil, uint32(4))]
}() | -*V5[atomic.LoadUint32(nil)]) >> st3.U1
}(map[rune][][]chan uint{*V5[uint32(V1[-rune('S')])]: [][]chan uint{append([]chan uint{27: make(chan uint)}, make(chan uint)), []chan uint{make(chan uint), make(chan uint)}}})] = +int64(32) - V1[^'O'] + V1[*V5[atomic.LoadUint32(nil)]]
_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = pg0_0, pb0, pb1, pach0, pach1, pach2, ast3, ast4, ast5, st3, st4, st5, st6, st7, pppf0, pppf1, papu32_0, papu32_1, papu32_2
} else {
var by3, by4 byte
var r0, r1 rune
var st3, st4, st5 struct {
Au0 []uint
Ch1 chan int16
Ch2 chan *[]bool
}
var pac0 *[]complex128
var g0_1 G0
g0_1 = g0_0
st0.C0 = complex128(am0[len(append([]*complex128{33: nil}, unsafe.SliceData([]complex128{5022.14i})))][+func(struct {
M0 map[uint64]*uint
M1 map[complex128]struct {
I64_0 int64
Af1 []float64
}
}, *uintptr, map[int32]*map[float32]struct {
}) complex128 {
ast0[2] = struct {
F0 float64
H1 float32
}{8769.4, float32(8469.5)}
return 2397.67i
}(struct {
M0 map[uint64]*uint
M1 map[complex128]struct {
I64_0 int64
Af1 []float64
}
}{map[uint64]*uint{uint64(83): nil}, map[complex128]struct {
I64_0 int64
Af1 []float64
}{705.06i: struct {
I64_0 int64
Af1 []float64
}{int64(32), make([]float64, 69)}}}, nil, map[int32]*map[float32]struct {
}{int32(47): nil})][+uint64(61)]) + -(+-func(**struct {
An0 any
}, rune) complex128 {
V2 = V2
return 6998.94i
}(nil, '\u3c7f') - +-(3951.55i + 5959.39i)) + (-+(*pac0)[len(make([]uintptr, 81))] - (+ +(*pac0)[38] + complex128(am1[-11/i][9982.32i][uint64(94)]) + +am1[36][am0[41][6698.81i][uint64(85)]][uint64(12)]))
by1 = + +by3 & by4
V3 = min(-<-st3.Ch1, +(int16(59)%<-st4.Ch1>>st5.Au0[len("nVdpVLbQ47y1jvW7N")]), <-st5.Ch1) << V3
pac0 = pac0
by4 = +by2
st2.Fnc1 = nil
st4 = struct {
Au0 []uint
Ch1 chan int16
Ch2 chan *[]bool
}{[]uint{}, st5.Ch1, func(uint, map[uint64]int32) chan *[]bool {
pac0 = pac0
return st4.Ch2
}(st5.Au0[aai0[^98^i][-(71+copy([]byte{byte(86), byte(4), byte(36), byte(15)}, "PyHGuRab1C6"))^int(i)]], map[uint64]int32{atomic.SwapUint64(nil, atomic.AddUint64(nil, uint64(77))): V4})}
_, _, _, _, _, _, _, _, _ = by3, by4, r0, r1, st3, st4, st5, pac0, g0_1
}
case <-make(chan byte):
switch +uint(64) {
case uint(int8(68)) - uint(i):
var by3, by4 byte
var m2 map[byte][]func(map[int8]int32, uint64, []uint64, *int64, G0, int8) func(int64, uint64, bool, int16, any, int64) uintptr
var fnc1 func(map[int64]uint64, uint64, struct {
}, map[int]chan chan complex128, float64, []struct {
Pb0 *bool
}) map[int64]struct {
Ch0 chan int
} = func(p0 map[int64]uint64, p1 uint64, p2 struct {
}, p3 map[int]chan chan complex128, p4 float64, p5 []struct {
Pb0 *bool
}) map[int64]struct {
Ch0 chan int
} {
p3 = p3
i = ^(-(48 &^ aai0[i][aai0[42][80]]) ^ copy(make([]struct {
St0 struct {
I32_0 int32
}
}, 25), append([]struct {
St0 struct {
I32_0 int32
}
}{struct {
St0 struct {
I32_0 int32
}
}{struct {
I32_0 int32
}{V4 * V4}}, struct {
St0 struct {
I32_0 int32
}
}{struct {
I32_0 int32
}{int32(6) >> uint(i) & V4}}, struct {
St0 struct {
I32_0 int32
}
}{struct {
I32_0 int32
}{int32(45) ^ V4}}}, struct {
St0 struct {
I32_0 int32
}
}{struct {
I32_0 int32
}{min(V4)}})))
return map[int64]struct {
Ch0 chan int
}{int64(43): struct {
Ch0 chan int
}{make(chan int)}}
}
by3 = +by2 & by1
by1 = +func(map[int32]*map[complex128]*byte) byte {
st1 = struct {
C0 complex128
G0_1 G0
}{+(-st0.C0 + +complex128(6348.52i)*complex128(am1[64][3058.67i][uint64(4)])), g0_0}
return byte(uint(88))
}(map[int32]*map[complex128]*byte{int32(uint(36)): nil})
V6 = V6
m2 = m2
by2 = + +by0
V5 = make(map[uint32]*rune, 93)
am0[copy(make([]struct {
By0 byte
}, 53&aai1[copy(make([]byte, aai0[84][91]), string([]byte{+(byte(9) % by3)}))][copy([]byte{byte(97), byte(32), byte(27)}, "pu849I")&^i^copy([]byte{by1}, *ast2[25].Ps0)+aai0[0][aai1[62][8]]]%aai0[aai1[copy([][]uintptr{make([]uintptr, int(int8(71))|aai1[aai0[aai0[34][93]&^copy([]map[int16]map[int16]map[float64]uint{61: make(map[int16]map[int16]map[float64]uint, 64)}, []map[int16]map[int16]map[float64]uint{map[int16]map[int16]map[float64]uint{int16(62): make(map[int16]map[float64]uint, 84)}})][40]][88-i|aai0[73][3]]), []uintptr{uintptr(atomic.AddUintptr(nil, unsafe.Offsetof(st2.St0)))}}, [][]uintptr{7: append([]uintptr{}, func([]chan byte) []uintptr {
st0 = struct {
C0 complex128
G0_1 G0
}{+7178.94i, g0_0}
return append(make([]uintptr, 87), uintptr(24))
}(make([]chan byte, aai0[96][25]))...)})][aai1[95][copy([]uint64{uint64(35), uint64(52)}, []uint64{uint64(9), uint64(46), uint64(16), uint64(21)})]]][39]), []struct {
By0 byte
}{struct {
By0 byte
}{by2 * by3}, struct {
By0 byte
}{byte(34)}, struct {
By0 byte
}{byte(V3)}})] = am0[aai0[49][copy(func(uintptr, []float32, complex128) []int {
V5[uint32(19)&^atomic.SwapUint32(nil, uint32(78))] = nil
return func(chan uint) []int {
by1 = +byte(99)
return []int{79, 5, 76}
}(make(chan uint))
}(uintptr(13), (*V2).St0.Ah0, 4654.06i), append(aai1[88], aai1[79]...))]]
st2.Fnc1 = st2.Fnc1
_, _, _, _ = by3, by4, m2, fnc1
default:
var an0 any
var ast3 []struct {
Ppu64_0 **uint64
Ppg0_1 **G0
H2 float32
St3 struct {
R0 rune
Ch1 chan int
}
}
var m2, m3, m4 map[int32]rune
var i32_1, i32_2, i32_3 int32
var ppst0 **struct {
Aup0 []uintptr
St1 struct {
C0 complex128
G0_1 G0
}
}
var st3 struct {
C0 complex128
}
var i1 int
var m5, m6, m7 map[uint32]map[uint64]**byte
i32_2 = int32(int8(52))
aai0 = aai1
by1 = byte(V3)*by2 | **m6[atomic.AddUint32(nil, ast2[i].U32_1)+atomic.AddUint32(nil, atomic.AddUint32(nil, ast1[88].U32_1))][+uint64(**m7[uint32(28)][uint64(97)])] | by2
by2 = by0 + **m5[uint32(int8(62))][atomic.SwapUint64(*ast3[len(string([]byte{20: byte(16)}))].Ppu64_0, uint64(45))]
by2 = byte(int8(0))
i1 = - -(int(byte(73)) * i) / i1
V5 = V5
m2 = m3
_, _, _, _, _, _, _, _, _, _, _, _, _, _ = an0, ast3, m2, m3, m4, i32_1, i32_2, i32_3, ppst0, st3, i1, m5, m6, m7
}
for ; ; V5 = map[uint32]*rune{+uint32(64): nil} {
var m2 map[complex128]*float64
var pst1, pst2, pst3 *struct {
Par0 *[]rune
Pi1 *int
M2 map[byte]struct {
G0_0 G0
I16_1 int16
I32_2 int32
I32_3 int32
}
}
var u64_0, u64_1 uint64
var ps0, ps1, ps2 *string
ps2 = ps0
aai0[(+i-*(*pst3).Pi1)/int(i)] = append(aai1[(^12|*(*pst2).Pi1|int(i))*int(i)&^int(i)], ^82-copy(append(make([]byte, 14 / *(*pst2).Pi1), byte(21)), *ps0+*ps1+(*ps1+("lC6DUq3I5wRzSE6fk"+"AoIYRHBF"))+strings.TrimFunc("Ltbzm5WOknXaS", nil)))
ps1 = ps1
u64_0 = +(+atomic.SwapUint64(nil, uint64(21)) ^ atomic.SwapUint64(nil, atomic.SwapUint64(nil, atomic.AddUint64(nil, uint64(4)))) + atomic.LoadUint64(nil))
ast1 = append([]struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{77: ast1[^int(uint(41))-*(*pst1).Pi1]}, ast2[96])
ps0 = ps2
V4 = min(-V4, int32(uint(46)), int32(26), min((*pst2).M2[byte(70)].I32_2, int32(99)+V4, V4, ^int32(91)%(*pst3).M2[byte(85)].I32_2)<<V4+(*pst2).M2[byte(89)/by0].I32_2^(*pst2).M2[by0].I32_2, int32(66))
st0 = struct {
C0 complex128
G0_1 G0
}{3924.84i, g0_0}
_, _, _, _, _, _, _, _, _ = m2, pst1, pst2, pst3, u64_0, u64_1, ps0, ps1, ps2
}
default:
make(chan uint) <- + +uint(97)
make(chan rune) <- ^(*V5[+(uint32(37) / ast1[16].U32_1)] & '\u8e9f') | -func(uintptr, struct {
St0 struct {
C0 complex128
M1 map[rune]bool
}
Pm1 *map[int8][]rune
Ch2 chan map[int64]float64
Ch3 chan [][]any
}) rune {
am1 = am0[2:8]
return rune(*V5[uint32(71)/ast2[69].U32_1]) + rune(*V5[ast1[64].U32_1])
}(unsafe.Sizeof(make(chan map[rune]struct {
})), struct {
St0 struct {
C0 complex128
M1 map[rune]bool
}
Pm1 *map[int8][]rune
Ch2 chan map[int64]float64
Ch3 chan [][]any
}{struct {
C0 complex128
M1 map[rune]bool
}{am0[aai0[len([]map[complex128]int{make(map[complex128]int, 51)})][84]][complex128(3528.32i)][uint64(10)], map[rune]bool{rune('Q'): int32(14) >= V4 && !true}}, nil, make(chan map[int64]float64), make(chan [][]any)})
}
for !reflect.DeepEqual(by0, make(chan []int)) {
var fnc1 func(struct {
Pup0 *uintptr
I1 int
M2 map[int64]int
M3 map[uint64]int64
}, rune, []chan map[int16]complex128, *struct {
I8_0 int8
}, ...int32) bool = func(p0 struct {
Pup0 *uintptr
I1 int
M2 map[int64]int
M3 map[uint64]int64
}, p1 rune, p2 []chan map[int16]complex128, p3 *struct {
I8_0 int8
}, p4 ...int32) bool {
am0 = make([]map[complex128]map[uint64]complex128, -+(int(aai0[22][16])+aai1[75][46]-int(i))-aai0[(^(99&copy([]int16{int16(86), int16(10)}, []int16{int16(21)})/copy(make([]byte, 38), "3FWlA8y0V37ZVbJDDH0"))+int(i))&aai0[i][aai0[i][41]]+i][i])
by1 = byte(by0)
i = +(i + copy([][]string{append(append(append([]string{"t3mzrNx"}, "xNPdYG5YydDT"), append([]string{}, make([]string, 98)...)...), append(make([]string, 13-p0.I1), unsafe.String(nil, 85))...), []string{}, append(append(make([]string, 21), "Wcc29x6UifNVUN"), strings.Join([]string{unsafe.String(nil, 99), string(make([]byte, 12))}, strings.TrimFunc("rwuEuAI86yjHhLncuFAF", nil)))}, [][]string{[]string{}}))
return !strings.Contains("mC14P", "P6EdBG9UfhUmh7")
}
var i1, i2 int
var by3, by4, by5 byte
ast0 = ast0
am0[copy(aai1[i1], make([]int, 76&^int(i1)))] = am0[i]
by3 = byte(uint(40))
by3 = +by2
ast1 = []struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{ast2[86/i1&copy(make([]map[bool]struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}, 73), []map[bool]struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}{map[bool]struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}{false: struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}{uint32(77), nil}}, map[bool]struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}{false: struct {
U32_0 uint32
Pst1 *struct {
C0 complex128
U32_1 uint32
}
}{uint32(62), nil}}})*aai1[i][51]%copy([]byte("pU"), strings.Join(make([]string, 65), "oisZyAAMC46DMzZLfpxn1e"))&^i]}
V5[+uint32(by0)] = nil
ast2 = append(make([]struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}, ^^+(i2^copy(append(make([]chan map[uint][]struct {
U32_0 uint32
An1 any
}, 42), []chan map[uint][]struct {
U32_0 uint32
An1 any
}{}...), func(map[complex128]chan uintptr, **chan *any) []chan map[uint][]struct {
U32_0 uint32
An1 any
} {
V5 = map[uint32]*rune{uint32(36): nil}
return []chan map[uint][]struct {
U32_0 uint32
An1 any
}{make(chan map[uint][]struct {
U32_0 uint32
An1 any
}), make(chan map[uint][]struct {
U32_0 uint32
An1 any
})}
}(make(map[complex128]chan uintptr, 5), nil)))|i2), ast2...)
V5 = make(map[uint32]*rune, 41&i2)
_, _, _, _, _, _ = fnc1, i1, i2, by3, by4, by5
}
select {
case <-make(chan int64):
{
var i16_1, i16_2 int16
var pai8_0 *[]int8
var i16_3 int16
var m2, m3, m4 map[float64][]map[uint64]*uint32
var c0 complex128
var aby0 []byte
var m5, m6, m7 map[uint32]struct {
St0 struct {
M0 map[int32]uintptr
Ch1 chan uint
}
}
var paaar0, paaar1 *[][][]rune
by2 = +(aby0[aai0[aai1[44][int(uint(14))*i]&aai0[copy(append(make([]map[string]*map[float32][]uint, 77), make([]map[string]*map[float32][]uint, 31)...), []map[string]*map[float32][]uint{61: map[string]*map[float32][]uint{"R8lm": nil}})][aai1[88][46]]][(-25-aai0[45][15])*i]] % by1)
c0 = func([]G0, G0) complex128 {
V6 = V6
return st0.C0
}(make([]G0, ^int((*pai8_0)[4])&i), g0_0)
V6 = V6
V5[uint32(<-m7[*m4[math.Max(2242.8, math.Sqrt(8136.5))][copy([]byte{90: byte(93)}, "oX5Sjv")][atomic.LoadUint64(nil)]].St0.Ch1)] = nil
V6 = V6
st0 = struct {
C0 complex128
G0_1 G0
}{+st0.C0 * func(struct {
Am0 []map[uint32]uintptr
R1 rune
I8_2 int8
}, map[uint32]func(complex128, []uint32) *uint64) complex128 {
am0[len(append(func(int64, map[float64][]struct {
Pu0 *uint
}, rune) []int16 {
m4[+float64(uint64(36))] = append([]map[uint64]*uint32{make(map[uint64]*uint32, 92), map[uint64]*uint32{uint64(6): nil}}, func() map[uint64]*uint32 {
m6[uint32(66)] = struct {
St0 struct {
M0 map[int32]uintptr
Ch1 chan uint
}
}{struct {
M0 map[int32]uintptr
Ch1 chan uint
}{map[int32]uintptr{int32(37): uintptr(69)}, make(chan uint)}}
return make(map[uint64]*uint32, 66)
}())
return append(func([]map[complex128]int16) []int16 {
i16_1 = int16(89) | i16_2
return make([]int16, 52)
}([]map[complex128]int16{make(map[complex128]int16, 91)}), int16(uint(27)))
}(V1[(*paaar1)[52][33][98]], map[float64][]struct {
Pu0 *uint
}{-ast0[97].F0: []struct {
Pu0 *uint
}{struct {
Pu0 *uint
}{nil}, struct {
Pu0 *uint
}{nil}, struct {
Pu0 *uint
}{nil}}}, (*paaar1)[76][75][22]), append(append(make([]int16, 50), func(*int16) []int16 {
pai8_0 = func(struct {
Ch0 chan **uint64
}, map[int64]float32, struct {
Ph0 *float32
}) *[]int8 {
aby0[90] = byte(42) &^ by0
return nil
}(struct {
Ch0 chan **uint64
}{make(chan **uint64)}, map[int64]float32{int64(45): float32(9430.5)}, struct {
Ph0 *float32
}{nil})
return make([]int16, 76)
}(nil)...), +int16(41)|i16_2)...))|i] = am1[73]
return 9060.67i
}(struct {
Am0 []map[uint32]uintptr
R1 rune
I8_2 int8
}{func(float32) []map[uint32]uintptr {
i16_1 = ^max(i16_1, i16_3)
return []map[uint32]uintptr{84: map[uint32]uintptr{+atomic.LoadUint32(m4[7140.6][99][uint64(69)]): uintptr(uintptr(39))}}
}(ast0[aai0[int(*m4[9064.8][23][uint64(82)])|int(i)][aai0[25][70]]].H1), ^*V5[uint32(int32(50))], -int8(45)}, map[uint32]func(complex128, []uint32) *uint64{uint32(51): nil}), g0_0}
i16_3 = ^int16((*pai8_0)[(aai0[copy([]byte{byte(68), byte(33), byte(77)}, "HbNSdJGHcP")][51]-aai0[i][61])&^int(i)])
m5 = make(map[uint32]struct {
St0 struct {
M0 map[int32]uintptr
Ch1 chan uint
}
}, aai0[60][copy(append([]map[byte][][]*uint{make(map[byte][][]*uint, func(float32) int {
m5 = make(map[uint32]struct {
St0 struct {
M0 map[int32]uintptr
Ch1 chan uint
}
}, 92)
return 90
}(float32(2960.5))-int(i))}, make(map[byte][][]*uint, 25*aai0[int(uint32(19))%aai0[83][29]][95])), append(append([]map[byte][][]*uint{4: map[byte][][]*uint{byte(53): [][]*uint{[]*uint{nil, nil, nil, nil}, []*uint{nil}, make([]*uint, 37)}}}, func(map[byte]chan map[int]int, []struct {
St0 struct {
}
Fnc1 func(byte, map[uint64]G0, int, map[string]string, map[uint]int8, ...map[bool]G0) *string
}, *uintptr) map[byte][][]*uint {
ast0 = append([]struct {
F0 float64
H1 float32
}{struct {
F0 float64
H1 float32
}{2047.5, float32(93.6)}, struct {
F0 float64
H1 float32
}{65.1, float32(855.0)}}, struct {
F0 float64
H1 float32
}{2788.4, float32(4513.8)})
return make(map[byte][][]*uint, 77)
}(make(map[byte]chan map[int]int, 22), []struct {
St0 struct {
}
Fnc1 func(byte, map[uint64]G0, int, map[string]string, map[uint]int8, ...map[bool]G0) *string
}{struct {
St0 struct {
}
Fnc1 func(byte, map[uint64]G0, int, map[string]string, map[uint]int8, ...map[bool]G0) *string
}{struct {
}{}, nil}}, nil)), map[byte][][]*uint{byte(95) * aby0[53]: append([][]*uint{[]*uint{nil, nil}}, []*uint{nil})}))]%int(i))
_, _, _, _, _, _, _, _, _, _, _, _, _, _ = i16_1, i16_2, pai8_0, i16_3, m2, m3, m4, c0, aby0, m5, m6, m7, paaar0, paaar1
}
st2 = struct {
St0 struct {
}
Fnc1 func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune
}{struct {
}{}, nil}
case <-make(chan bool):
select {
case <-make(chan complex128):
V1[(-rune(*V5[uint32(79)-ast1[21].U32_1])^((*V5[uint32(50)]-'\x2a')>>uint(87)|func(int8) rune {
ast2[^^92%aai1[aai0[47][3]][51]] = ast2[32]
return *V5[+uint32(53)]
}(int8(91))))>>uint(54)|+ +'\xb7'] = int64(V1[^(+(+'\xa1' | '\x65'>>uint(1)) - +'O'&(*V5[uint32(24)]&^'V'))])
ast2 = append([]struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{}, struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{nil, +(uint32(int8(28)) >> uint(i)) & ast1[aai0[aai1[aai1[copy(make([]int8, 47), []int8{60: int8(83)})][34]][len([]map[int8]map[int]**int16{4: make(map[int8]map[int]**int16, 2)})]][aai0[^83%aai0[80][86]][95]]].U32_1, nil})
case <-make(chan string):
aai0[max(func([]string, uint32) int {
V6 = V6
return int(V4)
}(make([]string, len([]G0{g0_0, g0_0, g0_0})), uint32(87)), aai0[len([][]chan struct {
Ch0 chan float32
Pi64_1 *int64
}{96: func(map[int8]map[int32]map[int64]string, *float64, [][]uint32) []chan struct {
Ch0 chan float32
Pi64_1 *int64
} {
by1 = +(byte(62) | by0) | by2
return make([]chan struct {
Ch0 chan float32
Pi64_1 *int64
}, -int(uint64(59))&aai0[copy([][]int32{}, [][]int32{[]int32{73: int32(83)}})][52])
}(make(map[int8]map[int32]map[int64]string, i*i), nil, [][]uint32{})})][i])/aai1[len(func(uint, map[int]struct {
Pg0_0 *G0
Up1 uintptr
}, map[int16]string) string {
am0 = append([]map[complex128]map[uint64]complex128{86: am0[len([]*G0{92: &g0_0})]}, map[complex128]map[uint64]complex128{func([]*complex128, float64) complex128 {
aai0 = [][]int{[]int{25, 50}}
return +(4631.21i + 2041.59i)
}([]*complex128{nil, nil, nil}, math.Max(math.Max(5431.6, 1653.9), ast0[99].F0)): am0[+59*copy([]int{24, 65}, make([]int, 49))][1812.46i]})
return strings.TrimFunc(strings.TrimFunc("C3E5Rq2CoUGKew", nil), nil) + (string(make([]byte, 61)) + ("" + "tn9pE3J2O4rqW") + strings.TrimFunc("wR6GZ0QRtXSvgypn39Lhi", nil))
}(uint(39), make(map[int]struct {
Pg0_0 *G0
Up1 uintptr
}, 23), map[int16]string{^+max(int16(51)&V3, int16(92)-V3): *ast1[int(copy([]byte{11: byte(67)}, "DE3E8eyP"))*int(i)].Ps0}))][len(*ast1[-int(byte(33))&^int(i)].Ps0)]] = append(make([]int, copy([][][]*[]int16{85: [][]*[]int16{[]*[]int16{nil}}}, [][][]*[]int16{96: append([][]*[]int16{[]*[]int16{2: nil}}, [][]*[]int16{[]*[]int16{nil}, make([]*[]int16, int(int8(14))/copy(make([]func(map[float32]struct {
M0 map[string]float32
M1 map[int8]int32
M2 map[complex128]int64
By3 byte
}, rune) []struct {
H0 float32
Ps1 *string
}, ^(0+copy([]byte{byte(7), byte(67), byte(14)}, "Ops0fPDyOQsp8"))|aai0[76][38]), []func(map[float32]struct {
M0 map[string]float32
M1 map[int8]int32
M2 map[complex128]int64
By3 byte
}, rune) []struct {
H0 float32
Ps1 *string
}{nil, nil})/copy(append(append(append(make([]int64, 68), []int64{int64(16), int64(61)}...), int64(17)|V1['\uac94']), int64(ast2[64].U32_1)), append(make([]int64, aai1[39&^i+i][19]/i), []int64{63: func(*map[uint32]struct {
Ch0 chan bool
I8_1 int8
}) int64 {
st0.C0 = 6646.42i - 2747.69i
return V1['H']
}(nil)}...)))}...)})|copy((*V2).St0.Ah0, []float32{})), copy([]**int8{nil, nil, nil}, []**int8{nil, unsafe.SliceData(make([]*int8, len([]*chan uint{84: nil})))}))
V1 = map[rune]int64{*V5[+ +(uint32(53)>>uint(i) | ast1[^34+aai0[80][74]].U32_1)]: V1[func(int) rune {
V6 = V6
return *V5[+uint32(99)] - '\u52e7' - rune(*V5[+uint32(62)])
}(0)]}
default:
am1[59] = func(map[uint64]func(map[uint32][]G0, struct {
}, chan func(uint64, uint64, uint64) bool, int) []*string, rune) map[complex128]map[uint64]complex128 {
aai1 = append([][]int{86: aai0[+(88+i)|aai1[26][61]]}, aai1...)
return am1[aai1[copy(make([]*[]chan []uint64, 87|aai1[29][75]), append([]*[]chan []uint64{nil}, []*[]chan []uint64{unsafe.SliceData(make([][]chan []uint64, 5)), nil}...))^i][len("6iTxxvGVMgEtxpdd1iQP")]]
}(map[uint64]func(map[uint32][]G0, struct {
}, chan func(uint64, uint64, uint64) bool, int) []*string{+ +atomic.AddUint64(nil, atomic.AddUint64(nil, atomic.AddUint64(nil, uint64(22)))) & atomic.SwapUint64(nil, atomic.SwapUint64(nil, atomic.SwapUint64(nil, uint64(38)))): nil}, *V5[+(+((uint32(53) - ast2[4].U32_1) << ast2[40].U32_1) - atomic.AddUint32(nil, ast1[min(44, 52, 32)*aai0[50][75]].U32_1))])
by0 = byte(34) & by0
}
V6 = nil
default:
am0 = am0[i+-((int(int32(25))+i+aai0[i][aai1[55][54]])%aai1[62][i&^aai0[min(55, 15, 72)%aai1[93][41]][46]]):]
if bool(reflect.DeepEqual(nil, nil)) {
var ch0, ch1 chan chan *float32
var st3 struct {
M0 map[float64]struct {
St0 struct {
Up0 uintptr
}
}
}
var pup0 *uintptr
V4 = V4 % V4 % V4
aai1 = append(func(any) [][]int {
V3 = -+V3
return [][]int{aai0[84], aai1[aai1[len(aai1[75])+int(i)][i]], []int{int(V3), 97}}
}(any(53)), []int{int(uint(6)), -len(min("0j4pT1EQCIVkMgq", "jzl2hhavVdjwOt0n"+"6V6FTqh1gAonre8HWK"))})
am1 = append(append(am1[i+(^^61+int(i)-aai0[31][-74^aai0[67][52]]):], map[complex128]map[uint64]complex128{complex128(9543.21i): am0[len("Nk1kRpXJqazqk")][complex128(1835.93i)]}), am1[^copy([]byte{byte(81)}, "JDbVL3PGx")&^aai0[aai0[len("dDczcXrfyx3daPwX55TwB9"+"Cnv9KGDWtyaY4sp")][len("no1lX8")|aai1[84][83]]][aai1[(3^int(i))&^int(i)][96]]])
aai1[len(*ast1[95*aai0[int(uint(86))&^i][min(-23, -18)-aai1[i][33]]].Ps0)&^int(i)] = func(*func(struct {
Fnc0 func() uint64
B1 bool
Ch2 chan float64
}, uintptr, struct {
R0 rune
I32_1 int32
F2 float64
}, struct {
Aby0 []byte
M1 map[rune]any
}) *func(rune, complex128, float64) G0, int64) []int {
ast1[aai0[43^copy(append(make([]byte, +19/i%int(i)), by2|by1), string(append(make([]byte, 4), byte(90)))+*ast2[17].Ps0+unsafe.String(nil, aai1[89][3]))][(-func(chan []int, *int16) int {
st1.C0 = func() complex128 {
by1 = +byte(88)
return 7123.80i
}()
return int(uint(59))
}(make(chan []int), nil)+int(i))&int(i)]] = struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{ast2[aai0[52][copy(make([]byte, 18), "ZvbxF9jN0Gs3iX7qQ2v")]%copy(append([]*float32{}, make([]*float32, (76+aai0[28][84])/i^i)...), make([]*float32, copy(make([]func(func(chan uint64) uint, func(float64, []float64, func(map[byte]uint64, map[float32]uint32, int, struct {
U32_0 uint32
I64_1 int64
}, uintptr, []uint64, ...[]any) int8, []map[uint]uint64) bool, func() int32, struct {
H0 float32
}, map[byte]struct {
By0 byte
}, map[bool]func(func(float64, int8, int64, float32, any) int16, map[bool]bool, *byte, struct {
I8_0 int8
}, *uint64, ...map[uintptr]any) *any, ...func(chan map[uint]any, uintptr, map[byte]float64) map[int8][]any) uint32, 90), make([]func(func(chan uint64) uint, func(float64, []float64, func(map[byte]uint64, map[float32]uint32, int, struct {
U32_0 uint32
I64_1 int64
}, uintptr, []uint64, ...[]any) int8, []map[uint]uint64) bool, func() int32, struct {
H0 float32
}, map[byte]struct {
By0 byte
}, map[bool]func(func(float64, int8, int64, float32, any) int16, map[bool]bool, *byte, struct {
I8_0 int8
}, *uint64, ...map[uintptr]any) *any, ...func(chan map[uint]any, uintptr, map[byte]float64) map[int8][]any) uint32, len(make([]any, 69))^int(i)))))].Ps0, uint32(V3), nil}
return aai1[aai0[aai1[int(V4)%i][+58|aai0[35][76]]][int(aai0[48][16])-aai1[aai1[73][55]][47]]]
}(nil, int64(16))
ast1[aai0[+len(append([]int8{int8(42)}, []int8{-int8(79), int8(49)}...))/aai1[aai0[aai1[68][i]][-len([]G0{47: g0_0})+copy(make([]struct {
I16_0 int16
Fnc1 func(struct {
I0 int
}, struct {
St0 struct {
}
}, []uint64, bool, uint32, func(uint64, struct {
B0 bool
By1 byte
}, int8, *int32) []bool, ...[]struct {
U32_0 uint32
}) []uint64
}, copy(make([]map[float32]func(map[int64]struct {
B0 bool
}, map[uintptr]*byte, struct {
Aan0 []any
}) uint64, 47), make([]map[float32]func(map[int64]struct {
B0 bool
}, map[uintptr]*byte, struct {
Aan0 []any
}) uint64, 85))), []struct {
I16_0 int16
Fnc1 func(struct {
I0 int
}, struct {
St0 struct {
}
}, []uint64, bool, uint32, func(uint64, struct {
B0 bool
By1 byte
}, int8, *int32) []bool, ...[]struct {
U32_0 uint32
}) []uint64
}{struct {
I16_0 int16
Fnc1 func(struct {
I0 int
}, struct {
St0 struct {
}
}, []uint64, bool, uint32, func(uint64, struct {
B0 bool
By1 byte
}, int8, *int32) []bool, ...[]struct {
U32_0 uint32
}) []uint64
}{int16(17), nil}})]][copy([]map[bool][]byte{map[bool][]byte{!false: append(make([]byte, 80), byte(99))}, map[bool][]byte{8725.2 >= math.Sqrt(432.7): append(make([]byte, 75), make([]byte, 47)...)}}, append([]map[bool][]byte{map[bool][]byte{false: []byte{byte(48), byte(67)}}}, make(map[bool][]byte, 73)))]][aai0[i][aai1[i][43*aai1[5][15]&^i]]]*aai0[copy(make([]chan struct {
St0 struct {
M0 map[int16]float64
Pb1 *bool
}
}, aai1[^19^i][3]), []chan struct {
St0 struct {
M0 map[int16]float64
Pb1 *bool
}
}{58: make(chan struct {
St0 struct {
M0 map[int16]float64
Pb1 *bool
}
})})/int(i)/i|aai0[(func(map[rune]**chan complex128, map[string][]func([]uint64, chan uint32, int32, struct {
F0 float64
U1 uint
}, any, chan complex128) map[complex128]int16) int {
i = int(len([]uint{uint(20)}))
return min(31^aai0[0][21], -36)
}(make(map[rune]**chan complex128, (i|aai1[24][60])/copy(append([]string{"3xEzfMJXxPW0RxqdzJUu"}, "Mh1M3vibRBHvBOAdazta1D0gfNxwCUDcjrUa"), append([]string{"aSvLqa7ASWrbTVre3x9xZDS", "ovYFwu8BRXTqm"}, "GmdW9toRq8g"))), map[string][]func([]uint64, chan uint32, int32, struct {
F0 float64
U1 uint
}, any, chan complex128) map[complex128]int16{strings.Join(make([]string, i|aai0[0][11]), *ast1[53].Ps0): []func([]uint64, chan uint32, int32, struct {
F0 float64
U1 uint
}, any, chan complex128) map[complex128]int16{nil}})-i)/int(i)][14+i]|copy(append([]byte(*ast2[18].Ps0+*ast2[60].Ps0), (byte(69)&by1-by1|by0)>>uint(i)), string([]byte{}))][^func(chan int8, any, int) int {
g0_0 = g0_0
return -^7 | aai0[25][57]
}(make(chan int8), any(52), len([]*chan map[bool]*uint64{}))*int(i)]] = ast1[copy([]byte{35: byte(68)}, max(*ast1[57].Ps0)+(*ast2[93].Ps0+strings.TrimFunc(*ast1[87].Ps0, nil)))]
st0.G0_1 = g0_0
V2 = V2
ch0 = make(chan chan *float32)
_, _, _, _ = ch0, ch1, st3, pup0
} else {
var pm0, pm1 *map[int]map[rune]struct {
U64_0 uint64
I8_1 int8
}
var ch0, ch1, ch2 chan int8
var apg0_0, apg0_1, apg0_2 []*G0
var u0, u1, u2 uint
by0 = +(+ +byte(51)/by0%by2)/by1 ^ by0
V6 = V6
ast0[int(ast1[^^+(73/i|aai1[10][12])*aai0[+^int(int8(66))-int(i)][28]].U32_1)%int(i)] = ast0[-aai0[copy(append([]uintptr{92: atomic.SwapUintptr(nil, uintptr(4))}, uintptr(50)), append(append([]uintptr{44: uintptr(13)}, []uintptr{}...), +uintptr(53)))][min(^40)&^aai0[min(9, 9, 92, 81)&copy(make([]byte, 93), "5LF7wlCS6zY1Mk")][62]]-aai0[aai1[i][aai1[aai1[14][92]][91]]^int(i)][9&i]]
V4 = -(^^(+int32(int32(89)) ^ V4) &^ V4)
by0 = byte(byte(87)) % by2
V2 = V2
st0 = struct {
C0 complex128
G0_1 G0
}{am0[len([]map[uint]int8{map[uint]int8{+u0: ^<-ch1}, map[uint]int8{u0: <-ch2}})&^int(i)][+(+st0.C0 * -8472.81i)][max(uint64(int32(48))%atomic.AddUint64(nil, uint64(36)))] - 639.67i, g0_0}
i = -int(uint(21))
_, _, _, _, _, _, _, _, _, _, _ = pm0, pm1, ch0, ch1, ch2, apg0_0, apg0_1, apg0_2, u0, u1, u2
}
}
if !strings.Contains(unsafe.String(nil, aai1[int(V4)|aai1[54&^int(i)-aai0[72][38]][69]-copy([]int32{V4}, []int32{})][52]), *ast1[10].Ps0) {
var m2 map[int8]string
var i32_1, i32_2 int32
var i16_1, i16_2 int16
var f0, f1 float64
var m3, m4, m5 map[int16]uint64
var pam0, pam1, pam2 *[]map[int64]int8
aai0 = append(aai0, append(aai0, aai1[+aai1[aai1[35][66]*i%int(i)][40]^aai0[aai1[20][aai1[46][78]]][54]])...)
pam0 = pam2
am1 = append(am1[:func(map[bool]struct {
}) int {
f0 = -3918.4
return ^(43 + aai1[56][63] - aai0[0][75]) ^ aai1[aai0[aai1[97][75]][29]][copy([]func() *[]*int16{36: nil}, []func() *[]*int16{nil})*aai0[76][54]]
}(map[bool]struct {
}{reflect.DeepEqual(make(map[float32]map[uint][]struct {
An0 any
I1 int
}, 53), struct {
M0 map[float64]string
St1 struct {
Ppg0_0 **G0
}
}{map[float64]string{f0: *ast1[aai1[i][30]].Ps0}, struct {
Ppg0_0 **G0
}{unsafe.SliceData([]*G0{nil})}}): st2.St0})+i], am0[aai1[len("CWVTFsZRXAoXDDVpt1"+("ChrusP8CyEv"+"e1"))][2]])
by1 = func(int16) byte {
V1['R'] = max(V1[^(rune(*V5[uint32(42)])>>uint(61))], min(V1[*V5[uint32(35)]]*V1[+'\x95']|V1[rune(*V5[uint32(25)])], int64(V3), int64(70)+V1[func(*func(byte, []int32, struct {
G0_0 G0
Pf1 *float64
}, uint, ...map[uint32]*uint) chan []float32, func(uintptr, uint64, ...uint) []string, chan func(...byte) float64) rune {
V2 = V2
return -'\u715a'
}(nil, nil, make(chan func(...byte) float64))]), int64(i16_1))
return +(byte((*pam0)[33][int64(47)]) & by1)
}(i16_2)
by2 = + +by1
pam2 = pam1
V1 = make(map[rune]int64, 46)
V1 = make(map[rune]int64, min(copy([]struct {
Aaaup0 [][][]uintptr
An1 any
}{struct {
Aaaup0 [][][]uintptr
An1 any
}{[][][]uintptr{}, any(6)}}, []struct {
Aaaup0 [][][]uintptr
An1 any
}{struct {
Aaaup0 [][][]uintptr
An1 any
}{append([][][]uintptr{47: make([][]uintptr, 33)}, [][]uintptr{[]uintptr{}, make([]uintptr, 30)}), any(90)}, struct {
Aaaup0 [][][]uintptr
An1 any
}{[][][]uintptr{append([][]uintptr{make([]uintptr, 26), []uintptr{uintptr(91), uintptr(47)}, []uintptr{uintptr(84)}}, append([][]uintptr{[]uintptr{uintptr(64)}, []uintptr{85: uintptr(84)}}, []uintptr{uintptr(37), uintptr(51), uintptr(48)})...), append([][]uintptr{37: []uintptr{uintptr(15)}}, make([][]uintptr, 50)...)}, any(any(86))}, struct {
Aaaup0 [][][]uintptr
An1 any
}{[][][]uintptr{15: [][]uintptr{55: func([]float64, struct {
An0 any
I1 int
Fnc2 func([]struct {
}, []*bool, int32) struct {
G0_0 G0
}
}) []uintptr {
st2 = struct {
St0 struct {
}
Fnc1 func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune
}{struct {
}{}, nil}
return []uintptr{uintptr(7)}
}([]float64{92: 8587.5}, struct {
An0 any
I1 int
Fnc2 func([]struct {
}, []*bool, int32) struct {
G0_0 G0
}
}{any(88), 33, nil})}}, any(any(99))}, struct {
Aaaup0 [][][]uintptr
An1 any
}{[][][]uintptr{13: make([][]uintptr, aai0[87][79])}, any(83)}})|copy(make([]byte, 46), *ast1[44].Ps0))*int(i)^copy(func(map[rune]G0) []byte {
m4[int16(uint32(57))] = uint64(V4) % atomic.SwapUint64(nil, uint64(44))
return []byte{by2 << by2}
}(make(map[rune]G0, ^^len([]rune{})&^i)), "QGKphQTMyDHIOwpUt7oZT5kA"+"5n6nKH0LvY9SS"))
_, _, _, _, _, _, _, _, _, _, _, _, _ = m2, i32_1, i32_2, i16_1, i16_2, f0, f1, m3, m4, m5, pam0, pam1, pam2
}
select {
case <-make(chan int):
by1 = min(+((+by1-by0)/by0), +(by1<<by0)) - by1
{
var u32_0, u32_1 uint32
var m2, m3, m4 map[uint64]*map[uint64]*int32
var i16_1, i16_2 int16
var st3 struct {
M0 map[float32]func(int, int64, chan uint64, *int32) float32
}
m2 = m3
aai0[aai0[-^aai1[-int(byte(99))^aai0[i+aai1[copy([]map[int16]int{0: map[int16]int{int16(53): 47}}, []map[int16]int{make(map[int16]int, 83), map[int16]int{int16(31): 9}})][78]][67/aai1[85][25]]][i]/copy(append(append(append([]byte{23: byte(33)}, by2), +by2), +byte(int32(17))&by2|by0), strings.TrimFunc(*ast1[62].Ps0, nil))][len(*ast2[69/copy([]*[]uintptr{93: nil}, make([]*[]uintptr, aai1[37][62]*aai1[8][59]))&^i].Ps0)]] = aai0[len(append([]func([]int32, func(G0) [][]int64, uint64, ...[]struct {
Pan0 *any
M1 map[byte]uintptr
M2 map[int]uint64
}) any{nil, nil, nil}, nil))]
V2 = V2
aai0[+^((copy([]uint32{54: uint32(55)}, []uint32{})+i)/i)/copy([]**[]uint64{nil}, append(append(make([]**[]uint64, aai1[(77-aai0[42][8]-i)%aai1[26][24]][^59-aai0[14][60]]), nil), nil))^i] = func(**any, int64) []int {
i16_1 = -min(V3, int16(uint(5)), -(int16(0)&i16_2)+i16_1, int16(87)) / V3
return aai1[min(aai0[90][59], aai0[aai0[len([][]float32{[]float32{float32(2216.2), float32(536.6), float32(5713.3)}})^int(i)][5]][72], +func(bool, byte) int {
ast2 = append(make([]struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}, 26), struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{nil, uint32(82), nil})
return copy(make([]byte, 3), "Jcfq5kZ4Sumx")
}(false, by1))&i]
}(nil, V1[func(int8, chan any) rune {
g0_0 = g0_0
return rune(*V5[ast2[27&^aai0[82][95]&aai1[56][84]].U32_1])
}(int8(56), make(chan any))])
m2[uint64(int32(58))] = nil
m2[+atomic.SwapUint64(nil, atomic.AddUint64(nil, atomic.LoadUint64(nil)))&^atomic.AddUint64(nil, atomic.SwapUint64(nil, atomic.AddUint64(nil, atomic.AddUint64(nil, atomic.AddUint64(nil, uint64(43))))))/atomic.LoadUint64(nil)] = nil
st3 = struct {
M0 map[float32]func(int, int64, chan uint64, *int32) float32
}{map[float32]func(int, int64, chan uint64, *int32) float32{+min((*V2).St0.Ah0[45], (*V2).St0.Ah0[13], - -(+float32(3596.0) - st3.M0[float32(7852.1)](45, int64(39), make(chan uint64), nil))): st3.M0[ast0[95].H1]}}
m4[atomic.AddUint64(nil, atomic.SwapUint64(nil, uint64(50)))] = nil
_, _, _, _, _, _, _, _ = u32_0, u32_1, m2, m3, m4, i16_1, i16_2, st3
}
case <-make(chan int8):
ast0[copy([]chan int32{make(chan int32), make(chan int32)}, append(append([]chan int32{30: make(chan int32)}, make(chan int32)), make(chan int32)))] = func() struct {
F0 float64
H1 float32
} {
ast1[i+aai1[-aai0[aai0[81][85]&aai1[13][75]/aai0[(17-aai0[70][64])%int(i)][70]][int(int8(88))%i]&i][copy(append([]byte("eOFk5POyWS2sk"), byte(int8(74))), "P2WrTBCqwIbzdp"+"rsVmu")]+int(i)] = struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{nil, atomic.AddUint32(nil, atomic.AddUint32(nil, atomic.LoadUint32(nil))), nil}
return struct {
F0 float64
H1 float32
}{+math.Max(5016.2, math.Sqrt(1278.5)), float32(int8(84)) * (*V2).St0.Ah0[20]}
}()
go V6(append(append(append(append(append(append(append([]*float64{5: nil}, nil), append([]*float64{nil}, []*float64{nil, nil, nil}...)...), func() []*float64 {
V1[rune('\x53')] = min(int64(74), int64(40))
return make([]*float64, 60)
}()...), nil), nil), make([]*float64, int(uint(99))+i)...), []*float64{68: nil}...), struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, any(22), func() []uint32 {
i = - -(int(int32(91))*aai0[4][42] ^ aai1[int(uint32(94))&copy([]uint{80: uint(78)}, make([]uint, 89))][10])
return []uint32{}
}(), make([][]int32, 88+i)}, append(append([]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{nil}, nil), func(rune) func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
} {
V6 = V6
return func(float32, func(map[int64]struct {
I8_0 int8
St1 struct {
U64_0 uint64
G0_1 G0
}
}, rune, map[uint32]int64) G0) func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
} {
V2 = V2
return nil
}(float32(4808.1), nil)
}(*V5[ast1[i*int(i)].U32_1])))
default:
switch uint(uint(89)) {
case uint(atomic.AddUint64(nil, atomic.SwapUint64(nil, atomic.AddUint64(nil, atomic.AddUint64(nil, atomic.LoadUint64(nil)))))):
var m2, m3, m4 map[float64]uintptr
var st3 struct {
}
var up0, up1 uintptr
var m5, m6 map[int8]chan [][]int32
var st4, st5 struct {
M0 map[uint][]uint32
}
V1[func(int64) rune {
aai0 = [][]int{39: aai0[49]}
return -func(*any, *chan func(int8) int8, []func() []map[int]uintptr) rune {
ast0 = ast0
return *V5[+uint32(int8(83))]
}(nil, nil, []func() []map[int]uintptr{21: nil})
}(int64(37))] = V1[*V5[uint32(8)>>uint(i)]] % V1[rune('@')]
ast2 = ast2
m4[+ +float64(V1[*V5[max(uint32(83), uint32(41), uint32(69))]&*V5[st4.M0[uint(27)][55]]])] = + +uintptr(uintptr(99)) | +(+uintptr(11) + +(uintptr(9) + uintptr(54))) + +atomic.SwapUintptr(nil, unsafe.Offsetof(st4.M0)) ^ uintptr(uintptr(56))&uintptr(atomic.AddUintptr(nil, m3[ast0[^31-i].F0]))
V6 = V6
V6 = V6
m5 = func(int8, **byte) map[int8]chan [][]int32 {
st5 = struct {
M0 map[uint][]uint32
}{make(map[uint][]uint32, ((int(uint(54))^copy(func(uint64) []int {
m4[4054.5*math.Sqrt(2421.2)] = uintptr(50) & uintptr(11)
return make([]int, 34)
}(atomic.LoadUint64(nil)), append(make([]int, 57), 93*int(i))))/aai0[68|int(i)][copy(make([]struct {
Paby0 *[]byte
}, 73), make([]struct {
Paby0 *[]byte
}, 19))]-aai0[26][26+i+i])&copy([]map[int]float64{map[int]float64{^(-+(26 ^ i) ^ copy([]byte{}, "krOaeoa6xSFfwgd"+"bGMI3MmoALjP4y17j5Wn2RGwaGhMhzgn"+"LT8zLC1fM5BD2G")): +((-(3961.5 / math.Ldexp(9065.4, 64)) + ast0[-15%aai0[11][41]].F0) * ast0[61%copy([]byte("iDTj0dpLLacwgLIv2iXOvC"), "L0aMCBY1k0"+"X05xGSh")].F0)}, map[int]float64{^((80 | i) / i) / int(i): -(-2735.3 / math.NaN()) * math.NaN()}}, []map[int]float64{15: make(map[int]float64, -aai0[97][23]&^int(i)&i&^copy([]map[string][]*[]byte{63: make(map[string][]*[]byte, len([]int16{int16(93)})&^int(i))}, make([]map[string][]*[]byte, i+aai1[copy([]chan uint{90: make(chan uint)}, []chan uint{})][90])))}))}
return m6
}(int8(90), nil)
m3[ast0[len([][]chan []int64{[]chan []int64{26: make(chan []int64)}, append(make([]chan []int64, 59), make([]chan []int64, copy([]float64{1066.8 - math.Ldexp(1166.8, 91), float64(uint(89))}, append([]float64{math.NaN()}, []float64{1868.7 + math.Sqrt(4192.8), +2735.8, 7562.8 - math.Ldexp(5520.6, 49)}...)))...), []chan []int64{make(chan []int64), make(chan []int64), make(chan []int64)}})].F0] = uintptr(atomic.LoadUintptr(nil)) & +(+ +(uintptr(95) | uintptr(66)) & (unsafe.Offsetof(st1.C0) &^ m3[+4803.9]) & (uintptr(up1) ^ +up0))
m4[math.Max(ast0[len(append(make([]struct {
}, (len(make([]struct {
U0 uint
H1 float32
}, (89-aai1[17][54])&^aai1[23][1]))^copy(make([]byte, ^19&aai1[51][71]), []byte{+byte(21), byte(97)}))*i), st3))&aai1[i][+(+84^aai0[28][17])+copy([]byte(unsafe.String(nil, 38)), func(*map[int32]*float32) string {
up0 = +uintptr(8)
return "Yl0pnd6AYBIHdCn"
}(nil)+"WBn34BOo9")]].F0, math.Ldexp(2884.9, len(append(append([]chan struct {
}{make(chan struct {
}), func(struct {
G0_0 G0
Pu32_1 *uint32
}, int16) chan struct {
} {
st0 = struct {
C0 complex128
G0_1 G0
}{complex128(7523.61i), g0_0}
return make(chan struct {
})
}(struct {
G0_0 G0
Pu32_1 *uint32
}{g0_0, nil}, int16(29))}, make(chan struct {
})), make(chan struct {
})))))] = unsafe.Alignof(func(chan map[float64]uint64, chan chan struct {
Ph0 *float32
}, uintptr) []func(bool) bool {
m2[-4729.1] = +(atomic.AddUintptr(nil, uintptr(25)) + m2[4775.1]) &^ uintptr(uintptr(90))
return []func(bool) bool{52: nil}
}(make(chan map[float64]uint64), make(chan chan struct {
Ph0 *float32
}), uintptr(47))) | uintptr(16)
_, _, _, _, _, _, _, _, _, _ = m2, m3, m4, st3, up0, up1, m5, m6, st4, st5
default:
var ch0, ch1, ch2 chan *chan struct {
U32_0 uint32
F1 float64
I2 int
}
var ch3, ch4 chan int64
var pai64_0 *[]int64
var h0, h1, h2 float32
var m2 map[int8]int16
var st3 struct {
St0 struct {
Fnc0 func(...[]uintptr) chan int16
Afnc1 []func(string) byte
Paan2 *[]any
I16_3 int16
}
St1 struct {
Aau32_0 [][]uint32
I1 int
}
}
var fnc1 func(int64, any, *[]struct {
S0 string
I64_1 int64
B2 bool
I64_3 int64
}, []func() *byte) []*float32 = func(p0 int64, p1 any, p2 *[]struct {
S0 string
I64_1 int64
B2 bool
I64_3 int64
}, p3 []func() *byte) []*float32 {
ch3 = make(chan int64)
ch2 = func(map[rune]*uint) chan *chan struct {
U32_0 uint32
F1 float64
I2 int
} {
V2 = V2
return make(chan *chan struct {
U32_0 uint32
F1 float64
I2 int
})
}(make(map[rune]*uint, func(int8, bool, any) int {
p2 = p2
return ^int(int8(86))
}(int8(34), (*p2)[aai1[max(func() int {
st1.C0 = -2139.21i
return 6
}())/(<-*<-ch0).I2][copy([]chan any{make(chan any)}, make([]chan any, 86))]].B2, any(29))%i))
by0 = +byte(uint(76))
st1 = struct {
C0 complex128
G0_1 G0
}{func(*map[rune]map[int8]map[int16]float64) complex128 {
ch2 = make(chan *chan struct {
U32_0 uint32
F1 float64
I2 int
})
return -(+func(rune) complex128 {
ast0[(<-*<-ch1).I2] = struct {
F0 float64
H1 float32
}{3518.1, float32(7776.2)}
return func(struct {
M0 map[int]chan func(bool, int, int64) int
}, struct {
Aas0 [][]string
I1 int
St2 struct {
Fnc0 func(map[bool]float32, chan uint64, chan uint64, bool, []rune, uintptr) rune
Fnc1 func(int16, int32, func() int32, rune, ...[]int8) struct {
F0 float64
}
I2 int
U32_3 uint32
}
Aach3 [][]chan uint
}) complex128 {
p2 = p2
return 2529.17i
}(struct {
M0 map[int]chan func(bool, int, int64) int
}{map[int]chan func(bool, int, int64) int{60: make(chan func(bool, int, int64) int)}}, struct {
Aas0 [][]string
I1 int
St2 struct {
Fnc0 func(map[bool]float32, chan uint64, chan uint64, bool, []rune, uintptr) rune
Fnc1 func(int16, int32, func() int32, rune, ...[]int8) struct {
F0 float64
}
I2 int
U32_3 uint32
}
Aach3 [][]chan uint
}{make([][]string, 54), 57, struct {
Fnc0 func(map[bool]float32, chan uint64, chan uint64, bool, []rune, uintptr) rune
Fnc1 func(int16, int32, func() int32, rune, ...[]int8) struct {
F0 float64
}
I2 int
U32_3 uint32
}{nil, nil, 68, uint32(6)}, [][]chan uint{make([]chan uint, 72)}})
}(*V5[uint32(75)]) + + +-8820.53i) - - -am0[(<-*<-ch0).I2][func(int64, *struct {
M0 map[uint32][]G0
}) complex128 {
m2[int8(91)] = int16(91) ^ V3
return 9836.75i
}(int64(99), nil)][uint64(14)]
}(nil), g0_0}
return make([]*float32, aai1[len(append([]func(int8, chan map[float32]func(byte, G0, int32, string, uintptr) byte, chan struct {
C0 complex128
Pi16_1 *int16
}, *[]chan int16, []chan int64, byte, ...int64) *[]struct {
}{46: nil}, nil))/i][7])
}
ch1 = make(chan *chan struct {
U32_0 uint32
F1 float64
I2 int
})
ast0 = append([]struct {
F0 float64
H1 float32
}{ast0[82], func(rune, func(uint, struct {
Am0 []map[byte]byte
St1 struct {
}
An2 any
}, float32) map[uintptr][]chan int16, *chan struct {
Ai0 []int
}, struct {
Fnc0 func(func() int64, struct {
Au32_0 []uint32
}, *struct {
By0 byte
I64_1 int64
}, float32, chan *int) *map[int64]uint64
An1 any
Ai32_2 []int32
}) struct {
F0 float64
H1 float32
} {
g0_0 = g0_0
return ast0[48|copy(make([]byte, 81), unsafe.String(nil, 93))]
}(*V5[uint32(V4)&(<-*<-ch0).U32_0], nil, nil, struct {
Fnc0 func(func() int64, struct {
Au32_0 []uint32
}, *struct {
By0 byte
I64_1 int64
}, float32, chan *int) *map[int64]uint64
An1 any
Ai32_2 []int32
}{func() func(func() int64, struct {
Au32_0 []uint32
}, *struct {
By0 byte
I64_1 int64
}, float32, chan *int) *map[int64]uint64 {
ast2 = ast2
return nil
}(), (*st3.St0.Paan2)[61], append([]int32{+V4, int32(uint64(24)) >> uint(i)}, make([]int32, -(52|i)^(<-*<-ch0).I2)...)})}, ast0[aai1[-(i*(<-*<-ch1).I2)&st3.St1.I1][(<-*<-ch1).I2^int(i)^copy([]byte("hViUauKS0huEMmC"), func([][]struct {
Pu0 *uint
As1 []string
M2 map[uint]uintptr
St3 struct {
By0 byte
H1 float32
}
}) string {
by0 = byte(97) ^ st3.St0.Afnc1[29]("wXqXYv6")
return "uZvZDSEo4H8EYxNrA"
}(make([][]struct {
Pu0 *uint
As1 []string
M2 map[uint]uintptr
St3 struct {
By0 byte
H1 float32
}
}, 88)))]])
ch0 = make(chan *chan struct {
U32_0 uint32
F1 float64
I2 int
})
V1 = V1
by1 = min(+((func(float64, chan struct {
G0_0 G0
R1 rune
S2 string
}, chan float64) byte {
i = +65
return byte(23)
}(4557.9, make(chan struct {
G0_0 G0
R1 rune
S2 string
}), make(chan float64))<<by2>>uint(i) + by1) / by1), +min(+ +(byte(83)%st3.St0.Afnc1[26]("w")), by2, +by0)&by0)
fnc1 = func(*chan uint64) func(int64, any, *[]struct {
S0 string
I64_1 int64
B2 bool
I64_3 int64
}, []func() *byte) []*float32 {
V4 = ^- -(int32(atomic.AddUint32(nil, uint32(72))) + V4)
return fnc1
}(nil)
st0.G0_1 = g0_0
aai0[-(<-*<-ch0).I2%aai1[st3.St1.I1][copy(make([]struct {
M0 map[rune]chan uint
Apaup1 []*[]uintptr
I16_2 int16
}, (33%(<-*<-ch2).I2^aai0[87][10])/copy(make([]struct {
St0 struct {
B0 bool
}
Afnc1 []func(string) map[int16]int64
Ar2 []rune
Am3 []map[uint32]func(uint64) uint
I64_4 int64
}, 38), append([]struct {
St0 struct {
B0 bool
}
Afnc1 []func(string) map[int16]int64
Ar2 []rune
Am3 []map[uint32]func(uint64) uint
I64_4 int64
}{99: struct {
St0 struct {
B0 bool
}
Afnc1 []func(string) map[int16]int64
Ar2 []rune
Am3 []map[uint32]func(uint64) uint
I64_4 int64
}{struct {
B0 bool
}{true}, make([]func(string) map[int16]int64, 71), []rune{'\xde', '8'}, make([]map[uint32]func(uint64) uint, 46), int64(45)}}, struct {
St0 struct {
B0 bool
}
Afnc1 []func(string) map[int16]int64
Ar2 []rune
Am3 []map[uint32]func(uint64) uint
I64_4 int64
}{struct {
B0 bool
}{false}, make([]func(string) map[int16]int64, 47), []rune{'8'}, make([]map[uint32]func(uint64) uint, 64), int64(80)}))^i), append([]struct {
M0 map[rune]chan uint
Apaup1 []*[]uintptr
I16_2 int16
}{}, struct {
M0 map[rune]chan uint
Apaup1 []*[]uintptr
I16_2 int16
}{make(map[rune]chan uint, 74-aai0[83][17]), append(append([]*[]uintptr{9: nil}, nil), []*[]uintptr{nil, nil, nil}...), +st3.St0.I16_3}))+(<-*<-ch0).I2]] = append(aai0[91], -func() int {
am0 = append(append(func(map[int]any) []map[complex128]map[uint64]complex128 {
ast1[49+(<-*<-ch0).I2] = func(struct {
}, []map[int64]map[float64][]any) struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
} {
h1 = float32(607.7) + ast0[0].H1
return struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{nil, uint32(23), nil}
}(struct {
}{}, []map[int64]map[float64][]any{make(map[int64]map[float64][]any, 52)})
return append([]map[complex128]map[uint64]complex128{23: map[complex128]map[uint64]complex128{6901.02i: map[uint64]complex128{uint64(92): 9231.88i}}}, map[complex128]map[uint64]complex128{1261.61i: make(map[uint64]complex128, 19)})
}(map[int]any{aai0[14][54]: (*st3.St0.Paan2)[44]}), func([]map[int]*uint32, rune) map[complex128]map[uint64]complex128 {
ch2 = make(chan *chan struct {
U32_0 uint32
F1 float64
I2 int
})
return make(map[complex128]map[uint64]complex128, 54)
}([]map[int]*uint32{map[int]*uint32{53 | (<-*<-ch0).I2: nil}}, '\x2a')), make([]map[complex128]map[uint64]complex128, len([]uint32{92: uint32(56)}))...)
return st3.St1.I1
}())
_, _, _, _, _, _, _, _, _, _, _, _ = ch0, ch1, ch2, ch3, ch4, pai64_0, h0, h1, h2, m2, st3, fnc1
}
st1 = struct {
C0 complex128
G0_1 G0
}{8702.37i, g0_0}
}
switch +uint32(88) {
case max(atomic.SwapUint32(nil, ast1[i].U32_1)&^atomic.SwapUint32(nil, uint32(26)), + +uint32(uint(50))):
var up0, up1, up2 uintptr
var ppby0, ppby1 **byte
var pfnc0, pfnc1, pfnc2 *func(map[int16]uint32, chan *float64, chan string, chan int16, struct {
Pg0_0 *G0
}, map[string]*int16) **float32
var u0, u1 uint
var pu64_0 *uint64
var ast3, ast4, ast5 []struct {
}
aai1 = append(append(append(append(aai1[:9], aai0[^98|aai1[18][63]^int(i)]), func() []int {
V3 = ^func(string, func(string, uint64, func(map[float64]func(int8, rune, ...bool) float32, any) *func(uint, float32, G0, uintptr, uint, rune, uint) string, *float32, *func(chan bool, *int, complex128, func(G0, float32, uint64) uint32, []int16, struct {
}, map[string]any) struct {
Up0 uintptr
}, map[int64]map[int64]uint64) *chan bool, struct {
}) int16 {
V5 = func(float64, struct {
Ch0 chan *chan uint64
}) map[uint32]*rune {
V5 = make(map[uint32]*rune, 96)
return map[uint32]*rune{uint32(66): nil}
}(6633.9, struct {
Ch0 chan *chan uint64
}{make(chan *chan uint64)})
return int16(93) - V3
}(strings.TrimFunc("jae5ujba", nil), nil, ast5[24])
return func() []int {
V1[('\u34c9'|'\xdf')>>uint(69)] = -(int64(75) &^ V1['I'])
return []int{96: aai0[32][1]}
}()
}()), append(aai0, aai0[i+int(atomic.AddUint32(nil, ast1[20].U32_1)):23+aai0[42&int(i)^aai1[38][37]][93]-aai1[len("AVo6adKeULY")][i]+i]...)...), append(append(aai1[+34*copy([]byte{+ +byte(32), byte(43) & **ppby0 & by2, byte(78) &^ **ppby1}, strings.Join(make([]string, ^68&i), unsafe.String(nil, 4)))], copy(make([][]uint, aai0[i][24]), make([][]uint, ^(97%aai1[8][66])|i^i))), +^i))
ppby1 = ppby1
by0 = byte(**ppby0)
V5 = V5
ast1 = append(append(append(ast1, []struct {
Ps0 *string
U32_1 uint32
Pm2 *map[uint32]string
}{97: ast2[len(make([][]*map[string]map[bool]uint64, 86*i*copy([]map[string]func(byte, bool, float64, uint32, ...*bool) *uint32{16: make(map[string]func(byte, bool, float64, uint32, ...*bool) *uint32, 62)}, []map[string]func(byte, bool, float64, uint32, ...*bool) *uint32{17: map[string]func(byte, bool, float64, uint32, ...*bool) *uint32{"GYLM1OLANF": nil}})))]}...), ast2[copy([]byte{}, unsafe.String(*ppby1, i))]), ast2[i])
pfnc2 = pfnc0
am1 = append(func([]struct {
M0 map[uint][]uintptr
M1 map[uintptr]string
Fnc2 func(rune, []complex128) map[string]int8
}) []map[complex128]map[uint64]complex128 {
V5 = V5
return append(append(func(uint32) []map[complex128]map[uint64]complex128 {
u0 = uint(int8(5))
return append(append([]map[complex128]map[uint64]complex128{50: map[complex128]map[uint64]complex128{5853.17i: make(map[uint64]complex128, 34)}}, make(map[complex128]map[uint64]complex128, 18)), append([]map[complex128]map[uint64]complex128{}, map[complex128]map[uint64]complex128{8000.16i: map[uint64]complex128{uint64(13): 5220.84i}})...)
}(uint32(20)), am0[^84^int(i)]), map[complex128]map[uint64]complex128{complex128(am1[copy(make([]int64, 81), make([]int64, 28))][9014.28i][uint64(14)]): am1[-70%i][8712.20i]})
}(make([]struct {
M0 map[uint][]uintptr
M1 map[uintptr]string
Fnc2 func(rune, []complex128) map[string]int8
}, 33)), make(map[complex128]map[uint64]complex128, aai0[52][aai1[86][85]]&^copy(func(float64, int) []*int64 {
aai0[aai1[aai1[31][68]][0]] = []int{65: func() int {
up0 = uintptr(98) & uintptr(2)
return 3
}()}
return append(func([]map[int16]*chan complex128, *[][]uint64, int64) []*int64 {
V3 = int16(uint64(57))
return []*int64{nil}
}([]map[int16]*chan complex128{make(map[int16]*chan complex128, 62)}, nil, int64(12)), nil)
}(math.Ldexp(math.Max(9580.4, 7057.4), i), copy([]**[]G0{}, []**[]G0{nil})), append([]*int64{nil}, nil))|i))
i = ^(^23 + aai0[aai1[78][copy(make([]map[float32]uint32, func(chan chan *chan any, struct {
Pm0 *map[rune]float32
Ps1 *string
I32_2 int32
}, uint64) int {
ppby1 = ppby0
return 67
}(make(chan chan *chan any), struct {
Pm0 *map[rune]float32
Ps1 *string
I32_2 int32
}{nil, nil, int32(36)}, uint64(48))+aai0[53][38]), make([]map[float32]uint32, 78&aai1[55][57]&^i))]][26])
_, _, _, _, _, _, _, _, _, _, _, _, _, _ = up0, up1, up2, ppby0, ppby1, pfnc0, pfnc1, pfnc2, u0, u1, pu64_0, ast3, ast4, ast5
default:
var ag0_0 []G0
var ch0 chan []chan string
var m2 map[uint32]struct {
M0 map[int64]func(uintptr, int, string, uint32, int8, rune) uintptr
}
var b0, b1 bool
aai1 = make([][]int, i&aai0[copy([]map[float64]float32{}, []map[float64]float32{map[float64]float32{float64(uint(98)): -float32(8627.3)}, map[float64]float32{3539.4 - math.Max(3174.6, 9031.0): float32(361.4) * ast0[79].H1}})][max(87^i, 82|copy(make([]struct {
Fnc0 func() byte
Ch1 chan *int
}, 93), make([]struct {
Fnc0 func() byte
Ch1 chan *int
}, 7)), -13)&^aai1[87][70]]*aai1[copy(make([]map[int32]map[int64]chan byte, (-len(make([]bool, 50))-aai0[(43-int(i))/aai1[62][85]][75])%aai1[aai1[len("k")%int(i)][76]][74]), []map[int32]map[int64]chan byte{49: make(map[int32]map[int64]chan byte, 64&aai0[aai0[aai1[96][17]][80]][len("HgLk61DoUfj7b8yP")/aai0[7][39]])})][len(func(map[int8][]chan *uint64) string {
st2 = struct {
St0 struct {
}
Fnc1 func(map[int16]chan uint32, rune, func(chan uint, *int32, any, chan int64) uint, []uint32) []*rune
}{st2.St0, nil}
return "F2F07dr6V4ThQ3EEp"
}(make(map[int8][]chan *uint64, aai1[58][20])))]&^i)
by2 = byte(25) % by0
V3 = V3 >> uint(i)
aai0[copy([]*[]*func(bool, any, uint, complex128, uint32) any{65: nil}, make([]*[]*func(bool, any, uint, complex128, uint32) any, copy([]rune{93: *V5[+(atomic.SwapUint32(nil, uint32(17)) >> uint(i))]}, []rune{50: +*V5[+(uint32(73) << ast2[26].U32_1)]})&^aai0[copy([]byte{}, strings.Join([]string{"jDcisMMLjPOr", "gEmpFhbN1eycq" + "TpvfDdX", "bptKAPM1DUDMetZhe"}, strings.Join([]string{43: ""}, "Q")))][4]))*i] = append(aai1[98&^aai1[aai1[len(unsafe.String(unsafe.StringData("d7PJercaNnPMXYfgWYGrl"), aai0[28][95]))][len([]struct {
M0 map[uintptr]float32
St1 struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}
}{struct {
M0 map[uintptr]float32
St1 struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}
}{map[uintptr]float32{uintptr(83): float32(3886.4)}, struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}{make(map[uint]func(float64, uintptr, complex128, any, int32, int) uint, 58), struct {
Pu32_0 *uint32
M1 map[int32]string
}{nil, map[int32]string{int32(25): "BqTZsgHIKsUqDFD"}}, map[int16]int8{int16(76): int8(57)}, nil}}, struct {
M0 map[uintptr]float32
St1 struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}
}{make(map[uintptr]float32, len(make([]int16, 33))-i), func() struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
} {
aai0 = [][]int{[]int{37, 41}, make([]int, 4)}
return struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}{map[uint]func(float64, uintptr, complex128, any, int32, int) uint{uint(29): nil}, struct {
Pu32_0 *uint32
M1 map[int32]string
}{nil, map[int32]string{int32(5): "yRcAernsWav913sVU"}}, make(map[int16]int8, 5), nil}
}()}, func([]string, any) struct {
M0 map[uintptr]float32
St1 struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}
} {
st2.St0 = struct {
}{}
return struct {
M0 map[uintptr]float32
St1 struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}
}{make(map[uintptr]float32, 29), struct {
M0 map[uint]func(float64, uintptr, complex128, any, int32, int) uint
St1 struct {
Pu32_0 *uint32
M1 map[int32]string
}
M2 map[int16]int8
Ps3 *string
}{map[uint]func(float64, uintptr, complex128, any, int32, int) uint{uint(37): nil}, struct {
Pu32_0 *uint32
M1 map[int32]string
}{nil, map[int32]string{int32(4): "xMeqsVEI1ct6SO"}}, map[int16]int8{int16(91): int8(67)}, nil}}
}(make([]string, 28), any(53))})+int(i)]][int(atomic.SwapUint32(nil, atomic.AddUint32(nil, uint32(8))))^aai0[i][7]]], make([]int, len(unsafe.String(unsafe.StringData(<-(<-ch0)[^92&copy([]byte{byte(21)}, "abLhafvSt4QaA")]), len(max("dI1dDAPkDke7Dqrte", "iVvfUO5GpNN3k0ceUL6Ym")+string([]byte{byte(40), byte(55)})+"q9UJNsBcuUBrCh"))))...)
V1[-(*V5[uint32(69)^atomic.AddUint32(nil, uint32(75))^atomic.LoadUint32(nil)]-'\u844a')&^-'1'>>uint(51)] = V1[^*V5[+atomic.AddUint32(nil, atomic.AddUint32(nil, uint32(37)))]] & V1['\u5195']
V6 = nil
aai0 = aai1[i + +copy(make([]struct {
Pch0 *chan []int8
}, +copy(make([]func(uint32, struct {
}, []int32, int32, *map[int32]chan bool, string, ...string) struct {
Up0 uintptr
Ch1 chan chan string
Pab2 *[]bool
M3 map[float32]uint
}, len("WHY9CiYb9BX")*int(i)*aai0[copy([]int8{int8(74), int8(30)}, []int8{int8(83)})][44]), []func(uint32, struct {
}, []int32, int32, *map[int32]chan bool, string, ...string) struct {
Up0 uintptr
Ch1 chan chan string
Pab2 *[]bool
M3 map[float32]uint
}{nil, nil})^int(i)), make([]struct {
Pch0 *chan []int8
}, aai1[len("HIgM9F")][+int(uint64(8))&^int(i)])) : ^len("rdXpDy9J"+*ast1[i].Ps0+string([]byte{by2 / by2, +byte(67)}))+i]
g0_0 = g0_0
_, _, _, _, _ = ag0_0, ch0, m2, b0, b1
}
defer V6(make([]*float64, +-(80^aai0[45][^34-aai0[77][28]])-aai0[aai0[4][23]][aai0[i][27]]), struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, any(74), []uint32{+uint32(int8(95)) * atomic.SwapUint32(nil, uint32(28)), +(ast2[len(make([][][]float32, 49))].U32_1 / ast1[copy(make([]byte, 9), "jGR8GPOG")].U32_1) << ast2[i].U32_1, atomic.AddUint32(nil, atomic.AddUint32(nil, uint32(99)))}, make([][]int32, aai0[98][aai0[int(V3)-aai1[-int(int32(15))|copy(func(uint) []*map[complex128]struct {
M0 map[float64]int64
Fnc1 func(uint32, uint32, uint32, uint64, float32, uint64, ...uint64) byte
M2 map[int32]uint
} {
V4 = ^int32(42)
return []*map[complex128]struct {
M0 map[float64]int64
Fnc1 func(uint32, uint32, uint32, uint64, float32, uint64, ...uint64) byte
M2 map[int32]uint
}{45: nil}
}(uint(49)), make([]*map[complex128]struct {
M0 map[float64]int64
Fnc1 func(uint32, uint32, uint32, uint64, float32, uint64, ...uint64) byte
M2 map[int32]uint
}, 80))][copy([]func() chan func(*bool, struct {
I8_0 int8
C1 complex128
I64_2 int64
B3 bool
}) uint64{nil, nil}, make([]func() chan func(*bool, struct {
I8_0 int8
C1 complex128
I64_2 int64
B3 bool
}) uint64, 98))]][aai0[75^int(i)|i][64]]]/i)}, append(append(append([]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{34: nil}, nil), nil), nil))
_, _, _, _, _, _, _, _, _ = ast1, ast2, by1, by2, aai0, aai1, st0, st1, st2
select {
case <-make(chan byte):
ast0 = func(*int32, chan struct {
Ppg0_0 **G0
U64_1 uint64
}, struct {
Paan0 *[]any
}) []struct {
F0 float64
H1 float32
} {
V5[+uint32(19)>>uint(i)] = nil
return ast0
}(nil, make(chan struct {
Ppg0_0 **G0
U64_1 uint64
}), struct {
Paan0 *[]any
}{nil})
defer V6(func() []*float64 {
am0[copy(make([]map[int64]map[int64]map[int16]struct {
U0 uint
}, (4^int(i))&i), append(append(make([]map[int64]map[int64]map[int16]struct {
U0 uint
}, i), make([]map[int64]map[int64]map[int16]struct {
U0 uint
}, copy(append(make([]*uint, 77), nil), append(func(struct {
R0 rune
}) []*uint {
g0_0 = g0_0
return []*uint{}
}(struct {
R0 rune
}{'\u4f62'}), nil)))...), map[int64]map[int64]map[int16]struct {
U0 uint
}{V1['A'>>uint(54)^-'\ub7f4']: map[int64]map[int16]struct {
U0 uint
}{V1[func([]*uint64, struct {
St0 struct {
F0 float64
}
St1 struct {
St0 struct {
}
Apc1 []*complex128
Fnc2 func(struct {
I64_0 int64
}, map[uint32]int32, uintptr, []int8, []uintptr, *byte) chan rune
Pfnc3 *func(...G0) float32
}
Pst2 *struct {
Ch0 chan uint32
Ps1 *string
Au32_2 []uint32
}
Fnc3 func(int16, rune, chan *int32, *chan rune) map[float32]struct {
}
}, int64) rune {
i = +59
return '\u2ab6'
}(make([]*uint64, 22), struct {
St0 struct {
F0 float64
}
St1 struct {
St0 struct {
}
Apc1 []*complex128
Fnc2 func(struct {
I64_0 int64
}, map[uint32]int32, uintptr, []int8, []uintptr, *byte) chan rune
Pfnc3 *func(...G0) float32
}
Pst2 *struct {
Ch0 chan uint32
Ps1 *string
Au32_2 []uint32
}
Fnc3 func(int16, rune, chan *int32, *chan rune) map[float32]struct {
}
}{struct {
F0 float64
}{4374.1}, struct {
St0 struct {
}
Apc1 []*complex128
Fnc2 func(struct {
I64_0 int64
}, map[uint32]int32, uintptr, []int8, []uintptr, *byte) chan rune
Pfnc3 *func(...G0) float32
}{struct {
}{}, make([]*complex128, 8), nil, nil}, nil, nil}, int64(12))|func(struct {
}) rune {
am1 = append(make([]map[complex128]map[uint64]complex128, 41), make([]map[complex128]map[uint64]complex128, 95)...)
return '\ub61c'
}(struct {
}{})]: map[int16]struct {
U0 uint
}{V3: struct {
U0 uint
}{uint(int32(72))}}}}))] = am0[61]
return make([]*float64, int(atomic.SwapUint64(nil, uint64(98)))&int(i)+copy(append([]rune{*V5[atomic.SwapUint32(nil, uint32(31))] + '\xe8'}, []rune{'\ub617'}...), append(append([]rune{46: *V5[+uint32(44)]}, []rune{}...), ^'9')))
}(), struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, any(4), make([]uint32, i&copy(append(append([]func(func(G0, map[int32][]int8, float64, **uint32, [][]string, struct {
I8_0 int8
}, chan int16) byte, *struct {
}) int64{}, nil), append([]func(func(G0, map[int32][]int8, float64, **uint32, [][]string, struct {
I8_0 int8
}, chan int16) byte, *struct {
}) int64{nil, nil}, append([]func(func(G0, map[int32][]int8, float64, **uint32, [][]string, struct {
I8_0 int8
}, chan int16) byte, *struct {
}) int64{nil, nil}, []func(func(G0, map[int32][]int8, float64, **uint32, [][]string, struct {
I8_0 int8
}, chan int16) byte, *struct {
}) int64{}...)...)...), make([]func(func(G0, map[int32][]int8, float64, **uint32, [][]string, struct {
I8_0 int8
}, chan int16) byte, *struct {
}) int64, 51^i))), append(func() [][]int32 {
V1 = V1
return [][]int32{make([]int32, int(89)*int(i)|i), []int32{}, []int32{V4, ^V4 ^ V4}, []int32{}}
}(), func() []int32 {
by0 = by0 % by0
return make([]int32, max(i, +int(int8(12)))^i)
}())}, func([]bool) []func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
} {
am0 = am1[i+copy(append(append(append([]struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{4: struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{nil, struct {
C0 complex128
}{7941.05i}}}, struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{nil, struct {
C0 complex128
}{2085.07i}}), struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{nil, struct {
C0 complex128
}{7550.76i}}), []struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{96: struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{nil, struct {
C0 complex128
}{745.13i}}}...), append(make([]struct {
Pps0 **string
St1 struct {
C0 complex128
}
}, i/copy(make([]G0, 96), []G0{g0_0, g0_0})), struct {
Pps0 **string
St1 struct {
C0 complex128
}
}{nil, struct {
C0 complex128
}{complex128(9648.36i)}}))/copy(append(append(append([]*func() []func(int64, int64, int, int) int64{}, nil), nil), nil), []*func() []func(int64, int64, int, int) int64{nil}) : ^+13+i]
return append([]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{nil}, nil)
}(make([]bool, i+copy(append(make([]int32, i), []int32{min(+V4, int32(97)>>uint(i)-V4, +int32(13)<<V4) >> uint(i)}...), func() []int32 {
V6 = V6
return []int32{V4 + V4}
}()))))
case <-make(chan bool):
for i1, st0 := range ast0 {
var st1 struct {
St0 struct {
}
M1 map[complex128]map[uint32]struct {
H0 float32
}
}
var fnc1 func([]uint32, map[rune]*uint, map[uintptr]any, map[int]int32, struct {
M0 map[int]int32
H1 float32
}, bool, *struct {
}) uint32 = func(p0 []uint32, p1 map[rune]*uint, p2 map[uintptr]any, p3 map[int]int32, p4 struct {
M0 map[int]int32
H1 float32
}, p5 bool, p6 *struct {
}) uint32 {
st0 = struct {
F0 float64
H1 float32
}{math.NaN(), -(+- -+st0.H1 / st1.M1[+(+8790.09i - func(*[]int16, *uint32, complex128) complex128 {
g0_0 = g0_0
return 3875.74i
}(nil, nil, 4884.42i))][uint32(uint32(49))].H0)}
i = int(36) | i
g0_0 = g0_0
V6 = func(struct {
Ach0 []chan struct {
U0 uint
F1 float64
B2 bool
}
}, byte, func(*map[string]int64, func(struct {
Up0 uintptr
B1 bool
}, complex128, *int32, []*byte) *func(uint32, bool, complex128, any, byte) byte, uint32, func(map[uint32][]int32, []bool, map[int32]func(rune, complex128, uint64, string) uint, [][]int, uint32, rune) uint64, ...map[uint]func(bool, []int, chan uint32, float64, map[rune]int64) G0) []any) func([]*float64, struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}, ...[]func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}) struct {
St0 struct {
St0 struct {
H0 float32
I8_1 int8
}
}
} {
p2[atomic.SwapUintptr(nil, unsafe.Offsetof(p4.H1))] = any(6)
return V6
}(struct {
Ach0 []chan struct {
U0 uint
F1 float64
B2 bool
}
}{make([]chan struct {
U0 uint
F1 float64
B2 bool
}, len(""+"qvyRuAWGQrMpDk"))}, byte(15), nil)
return +p0[i1] - atomic.AddUint32(nil, p0[i1])
}
var ch0, ch1, ch2 chan *uint
var u0 uint
var pup0 *uintptr
var i8_0 int8
var st2 struct {
St0 struct {
M0 map[uintptr]uint64
By1 byte
}
St1 struct {
Ast0 []struct {
I16_0 int16
U64_1 uint64
I16_2 int16
H3 float32
}
}
Ppu2 **uint
G0_3 G0
}
var m2, m3 map[int8]map[bool]*struct {
G0_0 G0
}
V6 = V6
i1 = -(int(V1[func(struct {
Ah0 []float32
H1 float32
}) rune {
V2 = V2
return '\x60'
}(struct {
Ah0 []float32
H1 float32
}{[]float32{+float32(5095.6), + +float32(2065.3), st1.M1[7421.34i][uint32(21)].H0}, +max(float32(5222.1), float32(1147.8), float32(7994.6), float32(6644.2))})]) * i)
i = i1 * i % int(i)
st0 = struct {
F0 float64
H1 float32
}{float64(i8_0), float32(V1[^(+rune('\u7e8f')&func(func(func([][]bool, struct {
}, byte, func(G0, struct {
U64_0 uint64
}, []string, []float32, *any, map[rune]uint64) chan int8, struct {
}) struct {
Pan0 *any
Ai32_1 []int32
}, []uint32, int, map[float64]chan int8, ...complex128) struct {
St0 struct {
Ch0 chan int64
}
M1 map[float32]func(int16, byte, complex128, rune, uint32, ...byte) string
}) rune {
u0 = uint(3) >> *<-ch0
return '\xfb'
}(nil))]) / st0.H1}
fnc1 = fnc1
i1 = -+int(atomic.AddUint32(nil, uint32(85)))
V2 = V2
am0[92] = map[complex128]map[uint64]complex128{am1[(+(3&^int(i))+copy(make([]chan uint, (8+int(i1))/copy(append(make([][]map[float32]map[uint32]chan int32, 69), []map[float32]map[uint32]chan int32{map[float32]map[uint32]chan int32{float32(4998.8): map[uint32]chan int32{uint32(73): make(chan int32)}}}), append([][]map[float32]map[uint32]chan int32{}, make([]map[float32]map[uint32]chan int32, 2)))), append(append([]chan uint{}, make(chan uint)), []chan uint{63: make(chan uint)}...)))&^i1][8491.27i][+uint64(V3)]: am0[-i&^i1][3013.74i]}
_, _, _, _, _, _, _, _, _, _, _ = st1, fnc1, ch0, ch1, ch2, u0, pup0, i8_0, st2, m2, m3
_, _ = i1, st0
}
{
var ast1, ast2, ast3 []struct {
Ch0 chan rune
St1 struct {
}
An2 any
}
var m2, m3 map[uint64]float32
var u0, u1 uint
var i1 int
var pan0, pan1 *any
var fnc1 func(struct {
M0 map[string]G0
}, struct {
Pch0 *chan uint32
U32_1 uint32
Am2 []map[complex128]float64
U32_3 uint32
}, float32, ...int8) bool = func(p0 struct {
M0 map[string]G0
}, p1 struct {
Pch0 *chan uint32
U32_1 uint32
Am2 []map[complex128]float64
U32_3 uint32
}, p2 float32, p3 ...int8) bool {
ast2[^+(+(func(chan chan int, []*[]uint, float64) int {
V2 = V2
return 93
}(make(chan chan int), make([]*[]uint, int(int64(76))&copy([][]chan []map[int32]uint32{make([]chan []map[int32]uint32, 1), []chan []map[int32]uint32{make(chan []map[int32]uint32)}}, make([][]chan []map[int32]uint32, 38))), 4583.2)/int(i))/copy([]byte{byte(V4), byte(14) / by0 &^ by0}, string([]byte{})))-int(i)] = struct {
Ch0 chan rune
St1 struct {
}
An2 any
}{ast1[i].Ch0, ast2[+len([]func(*rune, string) struct {
}{nil, nil, nil})%int(i)|int(i)].St1, ast2[- -(-73/i)%copy(append([]int{34: +81 % copy([]byte{byte(71)}, make([]byte, 87))}, []int{}...), []int{len(make([]string, -46-copy([]int8{int8(25)}, []int8{int8(8), int8(62)}))), i1 - int(i)})].An2}
am0 = append([]map[complex128]map[uint64]complex128{}, am1[i1^copy([]byte{54: +by0}, string([]byte{min(byte(76)&by0, by0), func(struct {
St0 struct {
}
St1 struct {
}
St2 struct {
I64_0 int64
}
}) byte {
am0 = []map[complex128]map[uint64]complex128{make(map[complex128]map[uint64]complex128, 73)}
return byte(97) ^ by0
}(struct {
St0 struct {
}
St1 struct {
}
St2 struct {
I64_0 int64
}
}{func([]func(map[int8]uint, int, chan struct {
}, []map[int16]uintptr) rune, chan string) struct {
} {
am1[14] = make(map[complex128]map[uint64]complex128, 63)
return struct {
}{}
}([]func(map[int8]uint, int, chan struct {
}, []map[int16]uintptr) rune{11: nil}, make(chan string)), struct {
}{}, struct {
I64_0 int64
}{int64(24)}}), byte(4) &^ by0, min(byte(41), byte(76), byte(40), byte(39)) / by0}))])
return uint64(66) == atomic.LoadUint64(nil)
}
var m4 map[uint64]int
func(func(map[complex128][]struct {
By0 byte
S1 string
}, map[uint32]func([]int16, map[int64]int) []int64) uint64, int32) uint {
i1 = (^((56 ^ copy(make([]func(...struct {
M0 map[int32][]int8
}) []rune, 11), make([]func(...struct {
M0 map[int32][]int8
}) []rune, 79)) + i1 - int(i)) & m4[uint64(i)]) ^ copy(make([]byte, 56-int(i1)), unsafe.String(unsafe.StringData(strings.TrimFunc(strings.Join(make([]string, 50), "dJ6dHMbpq0lea2fk"), nil)), 65))) * m4[+ +((uint64(19)|atomic.AddUint64(nil, uint64(3)))<<atomic.AddUint64(nil, uint64(6)))&atomic.SwapUint64(nil, uint64(18))]
return +(u0 * u0) | u0
}(nil, V4)
go func(float64, string) byte {
ast2[20] = struct {
Ch0 chan rune
St1 struct {
}
An2 any
}{ast3[i1].Ch0, ast1[+(len("Lz9gxTQJubnHb0vv9hUUtH3I")/i-int(i))&m4[+(+uint64(39)+atomic.LoadUint64(nil))]].St1, any(93)}
return +(by0 - by0)
}(math.Sqrt(8762.2), "GGF0")
switch + +uint32(V4) {
case uint32(uint(66)):
var up0, up1 uintptr
var i64_0, i64_1, i64_2 int64
var m5, m6 map[int16]bool
ast2 = append(func(chan *float64) []struct {
Ch0 chan rune
St1 struct {
}
An2 any
} {
V3 = +(V3 | V3)
return append(append(func(complex128) []struct {
Ch0 chan rune
St1 struct {
}
An2 any
} {
m4[+atomic.SwapUint64(nil, uint64(88))] = copy([]byte{}, "8LrBMPxdjh0pzD") / i
return append(ast2[2:19], ast2...)
}(am1[91][4284.72i][uint64(91)]), append(ast2, ast3[i1+91&^copy(make([]int16, 9), make([]int16, 52)):-(71&^i1)+i1]...)...), func(chan string, struct {
}) struct {
Ch0 chan rune
St1 struct {
}
An2 any
} {
V1[^+-'\u8b5d'] = +^i64_2
return ast2[(20^i1)*i]
}(make(chan string), struct {
}{}))
}(make(chan *float64)), struct {
Ch0 chan rune
St1 struct {
}
An2 any
}{ast1[40].Ch0, ast2[72].St1, *pan1})
ast2 = append(ast3, ast1[i])
pan1 = pan0
pan1 = pan0
V3 = +^-(int16(57)/V3&V3>>u0 | V3)
i64_1 = +^(-int64(66)|i64_1)<<i64_2 - V1[<-ast1[int(int8(91))&i/copy(func(map[string]map[uint64]chan struct {
}, uint) []byte {
ast0[(89|i1-m4[uint64(91)])&i] = struct {
F0 float64
H1 float32
}{+363.2, +float32(7344.1)}
return append([]byte{byte(28), byte(64)}, func(func(*map[int32]*int, map[rune]*map[uint64]string) map[uint][][]byte, bool) []byte {
m3 = make(map[uint64]float32, 84)
return make([]byte, 8)
}(nil, false)...)
}(map[string]map[uint64]chan struct {
}{"jklMdAwLMB" + "w99q": map[uint64]chan struct {
}{atomic.AddUint64(nil, uint64(74)): make(chan struct {
})}}, uint(71)), "rfRQavzIbG"+unsafe.String(nil, 84)+func([]struct {
Ch0 chan int64
St1 struct {
Ch0 chan float64
}
Fnc2 func() func(int16) float32
U32_3 uint32
}, int) string {
ast1 = func([]*byte, []map[complex128]**complex128, int64, map[uint64]struct {
Pup0 *uintptr
St1 struct {
}
I64_2 int64
St3 struct {
Pf0 *float64
}
}) []struct {
Ch0 chan rune
St1 struct {
}
An2 any
} {
ast1[88] = struct {
Ch0 chan rune
St1 struct {
}
An2 any
}{make(chan rune), struct {
}{}, any(21)}
return make([]struct {
Ch0 chan rune
St1 struct {
}
An2 any
}, 38)
}(make([]*byte, 12), []map[complex128]**complex128{map[complex128]**complex128{5499.24i: nil}}, int64(23), map[uint64]struct {
Pup0 *uintptr
St1 struct {
}
I64_2 int64
St3 struct {
Pf0 *float64
}
}{uint64(41): struct {
Pup0 *uintptr
St1 struct {
}
I64_2 int64
St3 struct {
Pf0 *float64
}
}{nil, struct {
}{}, int64(53), struct {
Pf0 *float64
}{nil}}})
return "MQWu1" + ""
}(make([]struct {
Ch0 chan int64
St1 struct {
Ch0 chan float64
}
Fnc2 func() func(int16) float32
U32_3 uint32
}, +4/i1), m4[uint64(53)]))].Ch0]
i64_2 = min(+i64_2) / i64_2
pan0 = pan1
_, _, _, _, _, _, _ = up0, up1, i64_0, i64_1, i64_2, m5, m6
default:
var an0, an1, an2 any
var ch0 chan func([]int32, func(func(uintptr, complex128, uint, float32, int8, uint32, int16) float32, []string, []uint32, *rune, func() G0, []int32) uint64, struct {
St0 struct {
I16_0 int16
B1 bool
I8_2 int8
}
St1 struct {
U32_0 uint32
}
Au64_2 []uint64
}, uintptr, float32, struct {
Ai16_0 []int16
}) *[]byte
var paapr0, paapr1 *[][]*rune
var fnc2 func(*uintptr, struct {
U32_0 uint32
H1 float32
}, func(uintptr, func(struct {
I64_0 int64
I64_1 int64
U2 uint
}, byte, struct {
B0 bool
}, ...*float64) []uint64, ...int) map[int32]struct {
}, *chan uint64, int16, map[uint32]float32) map[byte]*map[string]float64 = func(p0 *uintptr, p1 struct {
U32_0 uint32
H1 float32
}, p2 func(uintptr, func(struct {
I64_0 int64
I64_1 int64
U2 uint
}, byte, struct {
B0 bool
}, ...*float64) []uint64, ...int) map[int32]struct {
}, p3 *chan uint64, p4 int16, p5 map[uint32]float32) map[byte]*map[string]float64 {
an1 = func(map[int16]*int) any {
paapr0 = paapr0
return *&an2
}(map[int16]*int{int16(16): nil})
ast2[45] = ast2[93]
p0 = p0
return make(map[byte]*map[string]float64, i)
}
var afnc0 []func() map[uint32]chan any
u1 = u0 | u1
an0 = any(ast1[i1].An2)
pan0 = pan1
ast2 = ast3[i + +(int(i1)*int(i1)) : -99|i+i]
u0 = uint(atomic.LoadUint64(nil))
by0 = +byte(m4[uint64(83)%atomic.AddUint64(nil, atomic.LoadUint64(nil))]) % by0
V2 = V2
ast3[len(strings.Join(make([]string, 86), unsafe.String(nil, 40)))] = func(map[uint32]uintptr) struct {
Ch0 chan rune
St1 struct {
}
An2 any
} {
g0_0 = g0_0
return struct {
Ch0 chan rune
St1 struct {
}
An2 any
}{ast3[int(atomic.SwapUint32(nil, atomic.AddUint32(nil, uint32(98))))/i1].Ch0, ast1[i%m4[uint64(atomic.AddUint32(nil, uint32(39)))]].St1, ast3[7].An2}
}(map[uint32]uintptr{+ +(atomic.LoadUint32(nil) | atomic.AddUint32(nil, atomic.LoadUint32(nil))): +(unsafe.Sizeof(-6403.92i)&^unsafe.Alignof(+int32(29)))&^(atomic.LoadUintptr(nil)&unsafe.Sizeof(make(chan []byte))) + +(atomic.AddUintptr(nil, atomic.SwapUintptr(nil, uintptr(88))) &^ atomic.LoadUintptr(nil))})
_, _, _, _, _, _, _, _ = an0, an1, an2, ch0, paapr0, paapr1, fnc2, afnc0
}
fnc1 = func(chan int32) func(struct {
M0 map[string]G0
}, struct {
Pch0 *chan uint32
U32_1 uint32
Am2 []map[complex128]float64
U32_3 uint32
}, float32, ...int8) bool {
by0 = min(byte(V4), +byte(int16(62)), byte(uint(54)))
return fnc1
}(make(chan int32))
go fnc1(struct {
M0 map[string]G0
}{map[string]G0{strings.TrimFunc(strings.TrimFunc(unsafe.String(unsafe.StringData(strings.TrimFunc(strings.Join([]string{""}, ""), nil)), len("Va")), nil), nil): g0_0}}, struct {
Pch0 *chan uint32
U32_1 uint32
Am2 []map[complex128]float64
U32_3 uint32
}{nil, atomic.LoadUint32(nil), []map[complex128]float64{46: map[complex128]float64{-(am1[copy(make([]struct {
}, 10), []struct {
}{})][-4229.44i][uint64(42)] + am1[i][5614.95i+4067.54i][uint64(42)]): +math.Sqrt(math.Ldexp(math.NaN(), 65))}}, atomic.SwapUint32(nil, atomic.SwapUint32(nil, atomic.AddUint32(nil, atomic.AddUint32(nil, atomic.SwapUint32(nil, atomic.AddUint32(nil, atomic.AddUint32(nil, uint32(55))))))))}, +float32(int32(69)), -int8(48))
go fnc1(struct {
M0 map[string]G0
}{map[string]G0{unsafe.String(unsafe.StringData(unsafe.String(nil, i)), 5) + strings.TrimFunc(strings.Join([]string{strings.Join([]string{"mpRh1okCs0cqRssQIDzU" + "OnihTsl66wOS56T1qUdsu"}, strings.Join([]string{"ImSdVlL3sFp"}, "SUQJiSDGfcv1eR"))}, "EQD4ouU8axzEknj0HLiPI"), nil): g0_0}}, struct {
Pch0 *chan uint32
U32_1 uint32
Am2 []map[complex128]float64
U32_3 uint32
}{nil, uint32(u1)%atomic.AddUint32(nil, atomic.AddUint32(nil, atomic.AddUint32(nil, atomic.SwapUint32(nil, uint32(69))))) - atomic.LoadUint32(nil), []map[complex128]float64{44: map[complex128]float64{-am1[79][am1[31][6982.11i][uint64(58)]][uint64(1)] * -(9423.36i + 1675.65i - (6674.01i + 7097.73i) - (am0[80][5583.20i][uint64(55)] + am0[17][1893.33i][uint64(49)])): ast0[m4[atomic.SwapUint64(nil, atomic.LoadUint64(nil))]].F0 / ast0[^-^27*i].F0}}, + +atomic.SwapUint32(nil, atomic.LoadUint32(nil))}, float32(7844.3)/m3[+atomic.AddUint64(nil, atomic.AddUint64(nil, atomic.SwapUint64(nil, atomic.LoadUint64(nil))))], +int8(47))
clear(make(map[string]***[]int16, i1))
i1 = +copy([]byte{22: + +((byte(90) - by0) >> u1) + by0}, "GTxxvmaWz")
V5 = V5
go V6([]*float64{67: nil}, struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{unsafe.SliceData([]string{strings.Join([]string{"tVLr5rAx8"}, strings.Join([]string{strings.TrimFunc(unsafe.String(unsafe.StringData("rlVpjo0xEtizKygkNltrc5"), i1), nil)}, strings.Join([]string{55: "VV8SMckwLQa54jCrk" + (unsafe.String(nil, 61) + "VEKpMCODIGd")}, strings.Join([]string{strings.TrimFunc("3LcnxbTbX", nil), string(make([]byte, 70*m4[uint64(56)]&i)), "yOfYGjZW" + "V57qews4A6uGhgczMKOgsUkaK" + string([]byte{byte(94)})}, unsafe.String(unsafe.StringData("C2GNSjcVHkKCK3J"), copy(make([]struct {
Ac0 []complex128
}, 20), make([]struct {
Ac0 []complex128
}, 47)))))))}), *func() *any {
V5[uint32(90)] = nil
return pan1
}(), []uint32{+atomic.AddUint32(nil, atomic.SwapUint32(nil, atomic.AddUint32(nil, uint32(61)))), +(uint32(64) << atomic.AddUint32(nil, uint32(47))) ^ atomic.SwapUint32(nil, atomic.SwapUint32(nil, atomic.SwapUint32(nil, uint32(87)))), uint32(78) % atomic.AddUint32(nil, atomic.AddUint32(nil, uint32(81)))}, [][]int32{}}, []func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{66: nil})
_, _, _, _, _, _, _, _, _, _, _, _ = ast1, ast2, ast3, m2, m3, u0, u1, i1, pan0, pan1, fnc1, m4
}
default:
func(struct {
Pup0 *uintptr
}) bool {
am0 = append(am0, am1[22])
return bool(reflect.DeepEqual(- -3716.7-ast0[15].F0, -func() float64 {
am0[i] = func(struct {
Fnc0 func([]map[int16]string, []struct {
By0 byte
U32_1 uint32
}, float32, uint64, **uint64, rune) int
C1 complex128
}, struct {
Ai16_0 []int16
Aby1 []byte
}) map[complex128]map[uint64]complex128 {
by0 = max(+byte(51), byte(3)<<by0)
return am0[81]
}(struct {
Fnc0 func([]map[int16]string, []struct {
By0 byte
U32_1 uint32
}, float32, uint64, **uint64, rune) int
C1 complex128
}{nil, -complex128(8813.06i)}, struct {
Ai16_0 []int16
Aby1 []byte
}{make([]int16, 21&int(i)+copy(make([]chan [][]int32, 21), []chan [][]int32{76: make(chan [][]int32)})), []byte{func(float64) byte {
return byte(88)
}(9360.8), +byte(4)}})
return +-6912.4 / ast0[74].F0
}()))
}(struct {
Pup0 *uintptr
}{nil})
am0[^^int(by0)+copy(make([]int, func() int {
by0 = byte(89) / by0
return - -32 * int(i) / int(i)
}()&^copy(append([]*[]func(func() any, struct {
I16_0 int16
I1 int
S2 string
I8_3 int8
}, chan int) any{nil, nil}, nil), []*[]func(func() any, struct {
I16_0 int16
I1 int
S2 string
I8_3 int8
}, chan int) any{nil, nil})-i), []int{+ +(99%copy([]byte{byte(15), byte(86)}, "") ^ copy([][]map[int8]rune{[]map[int8]rune{75: make(map[int8]rune, ^61|i)}, make([]map[int8]rune, 29)}, [][]map[int8]rune{[]map[int8]rune{52: map[int8]rune{int8(0): 'N'}}, append([]map[int8]rune{map[int8]rune{int8(13): '\uba8d'}, map[int8]rune{int8(42): '\x81'}}, map[int8]rune{int8(17): '\xc0'}), append([]map[int8]rune{make(map[int8]rune, 55), make(map[int8]rune, 90), make(map[int8]rune, 78)}, make(map[int8]rune, 28)), func(func(G0, rune, int16, float32) map[int64]float64, uint, byte) []map[int8]rune {
return make([]map[int8]rune, 41)
}(nil, uint(40), byte(77))}) - int(i)), int(copy([]byte{91: byte(22)}, strings.TrimFunc("D2swDMp00iNkWrLRr", nil)+("rVU4POT5f1dXDsspZyWv"+"Dc"+("iu1K"+"bppybG9UNe9iscgw9ojEpJBlnRSlytVcOB")+("ZpIHTu72TQAkIS6jTG8a6"+unsafe.String(nil, 9)))))})] = am1[69]
}
func([]string) int {
return 0
}(make([]string, copy([][]int32{[]int32{V4}}, [][]int32{})))
func([][]func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8, *struct {
M0 map[complex128]struct {
H0 float32
}
St1 struct {
Ch0 chan int8
}
St2 struct {
}
}) any {
g0_0 = func(int64, func(map[uint]*map[bool]int, map[bool]*struct {
S0 string
Up1 uintptr
I64_2 int64
}, chan map[uint64][]int8, *chan *any, uint64, ...map[string]uint64) []chan byte) G0 {
am1[i-copy([]struct {
B0 bool
}{41: struct {
B0 bool
}{reflect.DeepEqual(nil, map[float64]func(*int8, bool, []rune, *struct {
B0 bool
}, chan []int64, uintptr) struct {
B0 bool
}{-+6682.7: nil})}}, append(make([]struct {
B0 bool
}, len(append(func(struct {
R0 rune
Fnc1 func(func(struct {
H0 float32
U32_1 uint32
}, *bool, map[uint32]uint, int16, complex128, struct {
I32_0 int32
}) []int, any, byte, struct {
St0 struct {
B0 bool
C1 complex128
}
Ac1 []complex128
Ph2 *float32
}) uint32
Pg0_2 *G0
}) []map[int8]struct {
} {
V1['\xe9'] = func(func([]struct {
I0 int
}, chan map[float32]chan int16, G0, struct {
G0_0 G0
}, *struct {
}, ...struct {
Ch0 chan string
C1 complex128
}) byte) int64 {
ast0[42] = struct {
F0 float64
H1 float32
}{3725.2, float32(175.8)}
return int64(36)
}(nil)
return []map[int8]struct {
}{}
}(struct {
R0 rune
Fnc1 func(func(struct {
H0 float32
U32_1 uint32
}, *bool, map[uint32]uint, int16, complex128, struct {
I32_0 int32
}) []int, any, byte, struct {
St0 struct {
B0 bool
C1 complex128
}
Ac1 []complex128
Ph2 *float32
}) uint32
Pg0_2 *G0
}{rune('\uba14'), nil, &g0_0}), make(map[int8]struct {
}, copy(make([]byte, 92), "nnz1AN"))))-int(i)), struct {
B0 bool
}{!strings.Contains(strings.TrimFunc("X", nil), "m")}))] = am0[46]
return g0_0
}(int64(81), nil)
return func(func([]map[byte]struct {
I64_0 int64
I64_1 int64
I2 int
}, func([]chan complex128, chan map[string]rune) struct {
Ai8_0 []int8
U64_1 uint64
}, map[uintptr]map[int]func(int32, rune, uint64, any, ...any) uint64, uint64) map[int16]int8) any {
return 71
}(nil)
}([][]func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8{[]func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8{9: nil}, []func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8{nil, nil, nil}, append([]func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8{nil}, func() func([]float32, float32, *int, uint64, map[uintptr]uintptr, []float32, any) int8 {
V4 = ^-+V4
return nil
}())}, nil)
go V6(append(append([]*float64{25: nil}, make([]*float64, ^(-88&^i)&^int(i)%int(i))...), []*float64{}...), struct {
Ps0 *string
An1 any
Au32_2 []uint32
Aai32_3 [][]int32
}{nil, any(89), make([]uint32, 88), [][]int32{[]int32{7: int32(16) &^ V4}, make([]int32, i*copy(func(*map[complex128]int64, float64, []struct {
I32_0 int32
Pst1 *struct {
}
Ach2 []chan rune
}, *int16) []byte {
return []byte(unsafe.String(nil, 38))
}(nil, 2414.3, []struct {
I32_0 int32
Pst1 *struct {
}
Ach2 []chan rune
}{struct {
I32_0 int32
Pst1 *struct {
}
Ach2 []chan rune
}{V4, nil, make([]chan rune, 36&^int(i))}}, nil), strings.Join([]string{95: "ep2rblWUBzwN"}, "7KDwysFN6ve")+"dltAX70wgS"+strings.Join(make([]string, +len("IxW7rxkCM")/int(i)), strings.TrimFunc("T4nbJ0xzeDYyMlgKsIz", nil))))}}, []func(map[uint32]float32, uint, struct {
I16_0 int16
S1 string
U32_2 uint32
I32_3 int32
}, ...struct {
U32_0 uint32
C1 complex128
}) struct {
I32_0 int32
U32_1 uint32
}{nil})
V4 = int32(10)
_, _, _, _ = am0, am1, ast0, by0
_ = g0_0
return uint32(i) * atomic.LoadUint32(nil), int64(copy([]struct {
M0 map[uint32]int64
St1 struct {
}
}{struct {
M0 map[uint32]int64
St1 struct {
}
}{map[uint32]int64{uint32(60) >> uint(i) << atomic.LoadUint32(nil) & atomic.LoadUint32(nil): int64(byte(67))}, struct {
}{}}, struct {
M0 map[uint32]int64
St1 struct {
}
}{map[uint32]int64{func() uint32 {
V2 = V2
return atomic.LoadUint32(nil)
}(): func([]int, int64) int64 {
V6 = V6
return +^int64(30)
}([]int{-45 ^ int(i), 68}, int64(65))}, struct {
}{}}}, append([]struct {
M0 map[uint32]int64
St1 struct {
}
}{struct {
M0 map[uint32]int64
St1 struct {
}
}{func(chan uint, []*[]any, *uintptr) map[uint32]int64 {
g0_0 = g0_0
return map[uint32]int64{uint32(22): int64(81)}
}(make(chan uint), make([]*[]any, 91/int(i)|int(i)), nil), struct {
}{}}, struct {
M0 map[uint32]int64
St1 struct {
}
}{make(map[uint32]int64, (len([]map[int]struct {
}{make(map[int]struct {
}, 84)})+i)%i), func(int16, rune) struct {
} {
V2 = V2
return struct {
}{}
}(V3, '\ua418')}}, struct {
M0 map[uint32]int64
St1 struct {
}
}{map[uint32]int64{atomic.LoadUint32(nil): V1['\ub68e'^'\u9c30']}, struct {
}{}}))), func(map[string]*string, func(*uintptr, byte, map[float32]func(*bool, []byte, float32, *bool, map[int16]string) struct {
U32_0 uint32
I1 int
}, []string, []int64, int32, bool) struct {
}, func(G0, chan *func() any) *bool) any {
V3 = int16(V1[+(func() rune {
i = ^76
return *V5[uint32(72)]
}() &^ +('\x8c' | '\x70'))])
return func([]bool, rune, map[string]map[int16]uint64) any {
V2 = V2
return any(80)
}(make([]bool, i%i%int(i)), *V5[+ +uint32(10)], map[string]map[int16]uint64{unsafe.String(nil, 1): map[int16]uint64{^((int16(73) + V3) * V3) | V3: +atomic.LoadUint64(nil)}})
}(map[string]*string{func(chan []map[int8]string, map[int8][][]uint64, float32) string {
V1[*V5[(uint32(63)-atomic.SwapUint32(nil, uint32(40))^atomic.SwapUint32(nil, uint32(96))|atomic.SwapUint32(nil, uint32(85)))<<atomic.LoadUint32(nil)]] = func(struct {
St0 struct {
R0 rune
Afnc1 []func(rune, int, rune) uint64
}
}, struct {
St0 struct {
H0 float32
An1 any
Up2 uintptr
U64_3 uint64
I16_4 int16
}
}, []*uint, []struct {
Ch0 chan []int8
}) int64 {
g0_0 = g0_0
return int64(16)
}(struct {
St0 struct {
R0 rune
Afnc1 []func(rune, int, rune) uint64
}
}{struct {
R0 rune
Afnc1 []func(rune, int, rune) uint64
}{-'\u6aa9', []func(rune, int, rune) uint64{}}}, struct {
St0 struct {
H0 float32
An1 any
Up2 uintptr
U64_3 uint64
I16_4 int16
}
}{struct {
H0 float32
An1 any
Up2 uintptr
U64_3 uint64
I16_4 int16
}{float32(byte(32)), any(53), uintptr(69), +(uint64(35) | atomic.AddUint64(nil, uint64(53))), V3}}, make([]*uint, 89+int(i)|copy(append(make([][]chan uint32, 67), [][]chan uint32{[]chan uint32{make(chan uint32), make(chan uint32), make(chan uint32)}, make([]chan uint32, 76)}...), append(make([][]chan uint32, 24), [][]chan uint32{make([]chan uint32, 54)}...))), []struct {
Ch0 chan []int8
}{struct {
Ch0 chan []int8
}{make(chan []int8)}, struct {
Ch0 chan []int8
}{make(chan []int8)}})&V1[+('A'&^'\ua138')] + V1[+*V5[+uint32(47)]]
return string(append(append(append([]byte("PXx02"), make([]byte, 28)...), max(byte(75), +byte(38), +byte(6))), byte(63)*byte(i)^byte(i)))
}(make(chan []map[int8]string), map[int8][][]uint64{int8(uint(96)) + int8(i): append(append(append([][]uint64{}, make([]uint64, copy([]chan chan complex128{make(chan chan complex128)}, []chan chan complex128{make(chan chan complex128)})-int(i))), make([]uint64, i&int(i))), append([]uint64{}, uint64(84)))}, float32(1411.6)): unsafe.SliceData(append(make([]string, copy([]byte("w1nfDg9PM5Wl"), string([]byte("r9cOvNVECeakUEtc"+"SzOkLvy03sg7wAYUeeSG")))^i), unsafe.String(unsafe.StringData("ESybR0oCE3TP6WDmP9j"), copy(make([]struct {
Ai8_0 []int8
M1 map[float64]struct {
Ar0 []rune
Pu1 *uint
}
Ab2 []bool
}, i), make([]struct {
Ai8_0 []int8
M1 map[float64]struct {
Ar0 []rune
Pu1 *uint
}
Ab2 []bool
}, copy([]chan *struct {
F0 float64
}{}, make([]chan *struct {
F0 float64
}, 59))%copy(make([][]map[uintptr]int64, 59), [][]map[uintptr]int64{[]map[uintptr]int64{make(map[uintptr]int64, 37), map[uintptr]int64{uintptr(20): int64(28)}, map[uintptr]int64{uintptr(44): int64(22)}, map[uintptr]int64{uintptr(85): int64(69)}}}))))))}, nil, nil), min(V3^V3, func(rune, struct {
An0 any
Ai64_1 []int64
Am2 []map[int32]int16
}) int16 {
V5 = V5
return min(V3, ^(int16(45) / V3 &^ V3), +(V3 / V3))
}(*V5[uint32(byte(83))], struct {
An0 any
Ai64_1 []int64
Am2 []map[int32]int16
}{func(uintptr, G0) any {
V4 = 23 + V4
return any(44)
}(unsafe.Offsetof(struct {
Ch0 chan byte
Up1 uintptr
}{make(chan byte), unsafe.Sizeof(reflect.DeepEqual(map[byte]struct {
Aan0 []any
}{byte(66): struct {
Aan0 []any
}{[]any{any(3)}}}, struct {
St0 struct {
M0 map[int8]int16
Pm1 *map[int8]rune
}
By1 byte
Papup2 *[]*uintptr
}{struct {
M0 map[int8]int16
Pm1 *map[int8]rune
}{map[int8]int16{}, nil}, byte(87), nil}))}.Up1), g0_0), append([]int64{}, []int64{(V1[+'\xa8'] - V1[-'\xca']) >> uint(i), -^V1['\u9f12'] - V1['V'], + +max(int64(19)&^V1['3'], V1['\x2e'], V1['X'])}...), make([]map[int32]int16, 7*copy([]func(map[byte]map[int16]int64, *int32, uint64, map[uint64]*struct {
R0 rune
B1 bool
S2 string
An3 any
I64_4 int64
}) int64{10: nil}, []func(map[byte]map[int16]int64, *int32, uint64, map[uint64]*struct {
R0 rune
B1 bool
S2 string
An3 any
I64_4 int64
}) int64{63: nil}))}))
}
func main() {
F[*int8]()
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment