PK���ȼRY��������€��� �v3.phpUT
�øŽg‰gñ“gux�
õ
��õ
��½T]kÛ0}߯pEhìâÙM7X‰çv%”v0֐µ{)Aå:6S$!ÉMJèߕ?R÷!>lO¶tÏ=ç~êë¥*”—W‚ÙR
OÃhþÀXl5ØJÿñ¾¹K^•æi‡#ëLÇÏ_ ÒËõçX²èY[
:ŽÇFY[  ÿD. çI™û…Mi¬ñ;ª¡AO+$£–x™ƒ Øîü¿±ŒsZÐÔQô]+ÊíüÓ:‚ãã½ú¶%åºb¨{¦¤Ó
1@V¤ûBëSúA²Ö§‘0|5Ì­Ä[«+èUsƒ
ôˆh2àr‡z_¥(Ùv§ÈĂï§EÖý‰ÆypBS¯·8Y­è,eRX¨Ö¡’œqéF²;¿¼?Ø?Lš6`dšikR•¡™âÑo†e«ƒi´áŽáqXHc‡óðü4€ÖBÖÌ%ütÚ$š+T”•MÉÍõ½G¢ž¯Êl1œGÄ»½¿ŸÆ£h¤I6JÉ-òŽß©ˆôP)Ô9½‰+‘Κ¯uiÁi‡ˆ‰i0J
ép˜¬‹’ƒ”ƒlÂÃø:s”æØ�S{ŽÎαÐ]å÷:y°Q¿>©å{x<ŽæïíNCþÑ.Mf?¨«2ý}=ûõýî'=£§ÿu•Ü(—¾IIa­"éþ@¶�¿ä
9?^-qìÇÞôvŠeÈc ðlacã®xèÄ'®âd¶çˆSEæódP/ÍÆv{Ô)Ó
?>…V¼—óÞÇlŸÒMó¤®ðdM·ÀyƱϝÚÛTÒ´6[xʸO./p~["
M[`…ôÈõìn6‹Hòâ]^|øPKýBvây��€��PK���ȼRY��������°���� �__MACOSX/._v3.phpUT
�øŽg‰gþ“gux�
õ
��õ
��c`cg`b`ðMLVðVˆP€'
qƒøˆŽ!!AP&HÇ
%PDF-1.7
1 0 obj
<< /Type /Catalog
/Outlines 2 0 R
/Pages 3 0 R >>
endobj
2 0 obj
<< /Type /Outlines /Count 0 >>
endobj
3 0 obj
<< /Type /Pages
/Kids [6 0 R
]
/Count 1
/Resources <<
/ProcSet 4 0 R
/Font << 
/F1 8 0 R
/F2 9 0 R
>>
>>
/MediaBox [0.000 0.000 595.280 841.890]
 >>
endobj
4 0 obj
[/PDF /Text ]
endobj
5 0 obj
<<
/Producer (���d�o�m�p�d�f� �2�.�0�.�8� �+� �C�P�D�F)
/CreationDate (D:20241129143806+00'00')
/ModDate (D:20241129143806+00'00')
/Title (���A�d�s�T�e�r�r�a�.�c�o�m� �i�n�v�o�i�c�e)
>>
endobj
6 0 obj
<< /Type /Page
/MediaBox [0.000 0.000 595.280 841.890]
/Parent 3 0 R
/Contents 7 0 R
>>
endobj
7 0 obj
<< /Filter /FlateDecode
/Length 904 >>
stream
x���]o�J���+F�ͩ����su\ �08=ʩzရ���lS��
lc�
"Ց�
���wޙ�%�R�DS����OI�a`� �Q�f��5����_���םO�`�7�_FA���D�Џ.j�a=�j����>��n���R+�P��l�rH�{0��w��0��=W�2D
����G���I�>�_B3ed�H�yJ�G>/��ywy�fk��%�$�2.��d_�h����&)b0��"[\B��*_.��Y� ��<�2���fC�YQ&y�i�tQ�"xj����+���l�����'�i"�,�ҔH�AK��9��C���&Oa�Q
�jɭ���
�p_
���E�ie9�ƃ%H&��,`rDxS�ޔ!�(�X!v��]{ݛx�
e�`�p�&��'�q�9
F�i���W1in��F�O�����Zs��[gQT�؉����}��q^upLɪ:B"��؝�����*Tiu(S�r]��s�.��s9n�N!K!L�M�?�*[��N�8��c��ۯ�b������YZ���SR3�n�����lPN��P�;��^�]�!'�z-���ӊ���/��껣��4�l(M�E�QL��X��~���G��M|�����*��~�;/=N4�-|y�`�i�\�e�T�<���L��G}�"В�J^���q��"X�?(V�ߣXۆ{��H[����P���c���kc�Z�9v�����?�a��R�h|��^�k�D4W���?Iӊ�]<��4�)$wdat���~���������
��|�L��x�p|N�*��E��/4�Qpi�x.>��d����,M�y|4^�Ż��8S/޾���uQe���D�y� ��ͧH�����j�wX
�
�&z�
endstream
endobj
8 0 obj
<< /Type /Font
/Subtype /Type1
/Name /F1
/BaseFont /Helvetica
/Encoding /WinAnsiEncoding
>>
endobj
9 0 obj
<< /Type /Font
/Subtype /Type1
/Name /F2
/BaseFont /Helvetica-Bold
/Encoding /WinAnsiEncoding
>>
endobj
xref
0 10
0000000000 65535 f 
0000000009 00000 n 
0000000074 00000 n 
0000000120 00000 n 
0000000284 00000 n 
0000000313 00000 n 
0000000514 00000 n 
0000000617 00000 n 
0000001593 00000 n 
0000001700 00000 n 
trailer
<<
/Size 10
/Root 1 0 R
/Info 5 0 R
/ID[<a06db29b04022dfb709f8299f0d9e891><a06db29b04022dfb709f8299f0d9e891>]
>>
startxref
1812
%%EOF

<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php:1) in <b>/home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php</b> on line <b>128</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php:1) in <b>/home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php</b> on line <b>129</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php:1) in <b>/home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php</b> on line <b>130</b><br />
<br />
<b>Warning</b>:  Cannot modify header information - headers already sent by (output started at /home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php:1) in <b>/home/u697396820/domains/smartriegroup.com/public_html/assets/images/partners/logo_69cec45839613.php</b> on line <b>131</b><br />
// run

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test independent goroutines modifying a comprehensive
// variety of vars during aggressive garbage collection.

// The point is to catch GC regressions like fixedbugs/issue22781.go

package main

import (
	"errors"
	"runtime"
	"runtime/debug"
	"sync"
)

const (
	goroutines = 8
	allocs     = 8
	mods       = 8

	length = 9
)

func main() {
	debug.SetGCPercent(1)
	var wg sync.WaitGroup
	for i := 0; i < goroutines; i++ {
		for _, t := range types {
			err := t.valid()
			if err != nil {
				panic(err)
			}
			wg.Add(1)
			go func(f modifier) {
				var wg2 sync.WaitGroup
				for j := 0; j < allocs; j++ {
					wg2.Add(1)
					go func() {
						f.t()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.pointerT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.arrayT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.sliceT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.mapT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.mapPointerKeyT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.chanT()
						wg2.Done()
					}()
					wg2.Add(1)
					go func() {
						f.interfaceT()
						wg2.Done()
					}()
				}
				wg2.Wait()
				wg.Done()
			}(t)
		}
	}
	wg.Wait()
}

type modifier struct {
	name           string
	t              func()
	pointerT       func()
	arrayT         func()
	sliceT         func()
	mapT           func()
	mapPointerKeyT func()
	chanT          func()
	interfaceT     func()
}

func (a modifier) valid() error {
	switch {
	case a.name == "":
		return errors.New("modifier without name")
	case a.t == nil:
		return errors.New(a.name + " missing t")
	case a.pointerT == nil:
		return errors.New(a.name + " missing pointerT")
	case a.arrayT == nil:
		return errors.New(a.name + " missing arrayT")
	case a.sliceT == nil:
		return errors.New(a.name + " missing sliceT")
	case a.mapT == nil:
		return errors.New(a.name + " missing mapT")
	case a.mapPointerKeyT == nil:
		return errors.New(a.name + " missing mapPointerKeyT")
	case a.chanT == nil:
		return errors.New(a.name + " missing chanT")
	case a.interfaceT == nil:
		return errors.New(a.name + " missing interfaceT")
	default:
		return nil
	}
}

var types = []modifier{
	modifier{
		name: "bool",
		t: func() {
			var a bool
			for i := 0; i < mods; i++ {
				a = !a
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *bool { return new(bool) }()
			for i := 0; i < mods; i++ {
				*a = !*a
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]bool{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] = !a[j]
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]bool, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] = !a[j]
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[bool]bool)
			for i := 0; i < mods; i++ {
				a[false] = !a[false]
				a[true] = !a[true]
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*bool]bool)
			for i := 0; i < length; i++ {
				a[new(bool)] = false
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, v := range a {
					a[k] = !v
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan bool)
			for i := 0; i < mods; i++ {
				go func() { a <- false }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(bool(false))
			for i := 0; i < mods; i++ {
				a = !a.(bool)
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uint8",
		t: func() {
			var u uint8
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uint8 { return new(uint8) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uint8{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uint8, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uint8]uint8)
			for i := 0; i < length; i++ {
				a[uint8(i)] = uint8(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uint8]uint8)
			for i := 0; i < length; i++ {
				a[new(uint8)] = uint8(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uint8)
			for i := 0; i < mods; i++ {
				go func() { a <- uint8(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uint8(0))
			for i := 0; i < mods; i++ {
				a = a.(uint8) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uint16",
		t: func() {
			var u uint16
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uint16 { return new(uint16) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uint16{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uint16, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uint16]uint16)
			for i := 0; i < length; i++ {
				a[uint16(i)] = uint16(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uint16]uint16)
			for i := 0; i < length; i++ {
				a[new(uint16)] = uint16(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uint16)
			for i := 0; i < mods; i++ {
				go func() { a <- uint16(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uint16(0))
			for i := 0; i < mods; i++ {
				a = a.(uint16) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uint32",
		t: func() {
			var u uint32
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uint32 { return new(uint32) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uint32{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uint32, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uint32]uint32)
			for i := 0; i < length; i++ {
				a[uint32(i)] = uint32(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uint32]uint32)
			for i := 0; i < length; i++ {
				a[new(uint32)] = uint32(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uint32)
			for i := 0; i < mods; i++ {
				go func() { a <- uint32(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uint32(0))
			for i := 0; i < mods; i++ {
				a = a.(uint32) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uint64",
		t: func() {
			var u uint64
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uint64 { return new(uint64) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uint64{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uint64, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uint64]uint64)
			for i := 0; i < length; i++ {
				a[uint64(i)] = uint64(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uint64]uint64)
			for i := 0; i < length; i++ {
				a[new(uint64)] = uint64(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uint64)
			for i := 0; i < mods; i++ {
				go func() { a <- uint64(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uint64(0))
			for i := 0; i < mods; i++ {
				a = a.(uint64) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "int8",
		t: func() {
			var u int8
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *int8 { return new(int8) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]int8{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]int8, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[int8]int8)
			for i := 0; i < length; i++ {
				a[int8(i)] = int8(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*int8]int8)
			for i := 0; i < length; i++ {
				a[new(int8)] = int8(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int8)
			for i := 0; i < mods; i++ {
				go func() { a <- int8(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(int8(0))
			for i := 0; i < mods; i++ {
				a = a.(int8) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "int16",
		t: func() {
			var u int16
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *int16 { return new(int16) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]int16{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]int16, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[int16]int16)
			for i := 0; i < length; i++ {
				a[int16(i)] = int16(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*int16]int16)
			for i := 0; i < length; i++ {
				a[new(int16)] = int16(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int16)
			for i := 0; i < mods; i++ {
				go func() { a <- int16(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(int16(0))
			for i := 0; i < mods; i++ {
				a = a.(int16) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "int32",
		t: func() {
			var u int32
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *int32 { return new(int32) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]int32{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]int32, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[int32]int32)
			for i := 0; i < length; i++ {
				a[int32(i)] = int32(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*int32]int32)
			for i := 0; i < length; i++ {
				a[new(int32)] = int32(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int32)
			for i := 0; i < mods; i++ {
				go func() { a <- int32(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(int32(0))
			for i := 0; i < mods; i++ {
				a = a.(int32) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "int64",
		t: func() {
			var u int64
			for i := 0; i < mods; i++ {
				u++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *int64 { return new(int64) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]int64{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]int64, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[int64]int64)
			for i := 0; i < length; i++ {
				a[int64(i)] = int64(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*int64]int64)
			for i := 0; i < length; i++ {
				a[new(int64)] = int64(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int64)
			for i := 0; i < mods; i++ {
				go func() { a <- int64(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(int64(0))
			for i := 0; i < mods; i++ {
				a = a.(int64) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "float32",
		t: func() {
			u := float32(1.01)
			for i := 0; i < mods; i++ {
				u *= 1.01
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *float32 { return new(float32) }()
			*a = 1.01
			for i := 0; i < mods; i++ {
				*a *= 1.01
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]float32{}
			for i := 0; i < length; i++ {
				a[i] = float32(1.01)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= 1.01
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]float32, length)
			for i := 0; i < length; i++ {
				a[i] = float32(1.01)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= 1.01
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[float32]float32)
			for i := 0; i < length; i++ {
				a[float32(i)] = float32(i) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= 1.01
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*float32]float32)
			for i := 0; i < length; i++ {
				a[new(float32)] = float32(i) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= 1.01
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan float32)
			for i := 0; i < mods; i++ {
				go func() { a <- float32(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(float32(0))
			for i := 0; i < mods; i++ {
				a = a.(float32) * 1.01
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "float64",
		t: func() {
			u := float64(1.01)
			for i := 0; i < mods; i++ {
				u *= 1.01
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *float64 { return new(float64) }()
			*a = 1.01
			for i := 0; i < mods; i++ {
				*a *= 1.01
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]float64{}
			for i := 0; i < length; i++ {
				a[i] = float64(1.01)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= 1.01
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]float64, length)
			for i := 0; i < length; i++ {
				a[i] = float64(1.01)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= 1.01
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[float64]float64)
			for i := 0; i < length; i++ {
				a[float64(i)] = float64(i) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= 1.01
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*float64]float64)
			for i := 0; i < length; i++ {
				a[new(float64)] = float64(i) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= 1.01
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan float64)
			for i := 0; i < mods; i++ {
				go func() { a <- float64(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(float64(0))
			for i := 0; i < mods; i++ {
				a = a.(float64) * 1.01
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "complex64",
		t: func() {
			c := complex64(complex(float32(1.01), float32(1.01)))
			for i := 0; i < mods; i++ {
				c = complex(real(c)*1.01, imag(c)*1.01)
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *complex64 { return new(complex64) }()
			*a = complex64(complex(float32(1.01), float32(1.01)))
			for i := 0; i < mods; i++ {
				*a *= complex(real(*a)*1.01, imag(*a)*1.01)
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]complex64{}
			for i := 0; i < length; i++ {
				a[i] = complex64(complex(float32(1.01), float32(1.01)))
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]complex64, length)
			for i := 0; i < length; i++ {
				a[i] = complex64(complex(float32(1.01), float32(1.01)))
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[complex64]complex64)
			for i := 0; i < length; i++ {
				a[complex64(complex(float32(i), float32(i)))] = complex64(complex(float32(i), float32(i))) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*complex64]complex64)
			for i := 0; i < length; i++ {
				a[new(complex64)] = complex64(complex(float32(i), float32(i))) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan complex64)
			for i := 0; i < mods; i++ {
				go func() { a <- complex64(complex(float32(i), float32(i))) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(complex64(complex(float32(1.01), float32(1.01))))
			for i := 0; i < mods; i++ {
				a = a.(complex64) * complex(real(a.(complex64))*1.01, imag(a.(complex64))*1.01)
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "complex128",
		t: func() {
			c := complex128(complex(float64(1.01), float64(1.01)))
			for i := 0; i < mods; i++ {
				c = complex(real(c)*1.01, imag(c)*1.01)
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *complex128 { return new(complex128) }()
			*a = complex128(complex(float64(1.01), float64(1.01)))
			for i := 0; i < mods; i++ {
				*a *= complex(real(*a)*1.01, imag(*a)*1.01)
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]complex128{}
			for i := 0; i < length; i++ {
				a[i] = complex128(complex(float64(1.01), float64(1.01)))
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]complex128, length)
			for i := 0; i < length; i++ {
				a[i] = complex128(complex(float64(1.01), float64(1.01)))
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[complex128]complex128)
			for i := 0; i < length; i++ {
				a[complex128(complex(float64(i), float64(i)))] = complex128(complex(float64(i), float64(i))) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*complex128]complex128)
			for i := 0; i < length; i++ {
				a[new(complex128)] = complex128(complex(float64(i), float64(i))) + 0.01
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan complex128)
			for i := 0; i < mods; i++ {
				go func() { a <- complex128(complex(float64(i), float64(i))) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(complex128(complex(float64(1.01), float64(1.01))))
			for i := 0; i < mods; i++ {
				a = a.(complex128) * complex(real(a.(complex128))*1.01, imag(a.(complex128))*1.01)
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "byte",
		t: func() {
			var a byte
			for i := 0; i < mods; i++ {
				a++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *byte { return new(byte) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]byte{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]byte, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[byte]byte)
			for i := 0; i < length; i++ {
				a[byte(i)] = byte(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*byte]byte)
			for i := 0; i < length; i++ {
				a[new(byte)] = byte(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan byte)
			for i := 0; i < mods; i++ {
				go func() { a <- byte(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(byte(0))
			for i := 0; i < mods; i++ {
				a = a.(byte) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "rune",
		t: func() {
			var a rune
			for i := 0; i < mods; i++ {
				a++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *rune { return new(rune) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]rune{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]rune, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[rune]rune)
			for i := 0; i < length; i++ {
				a[rune(i)] = rune(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*rune]rune)
			for i := 0; i < length; i++ {
				a[new(rune)] = rune(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan rune)
			for i := 0; i < mods; i++ {
				go func() { a <- rune(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(rune(0))
			for i := 0; i < mods; i++ {
				a = a.(rune) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uint",
		t: func() {
			var a uint
			for i := 0; i < mods; i++ {
				a++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uint { return new(uint) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uint{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uint, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uint]uint)
			for i := 0; i < length; i++ {
				a[uint(i)] = uint(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uint]uint)
			for i := 0; i < length; i++ {
				a[new(uint)] = uint(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uint)
			for i := 0; i < mods; i++ {
				go func() { a <- uint(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uint(0))
			for i := 0; i < mods; i++ {
				a = a.(uint) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "int",
		t: func() {
			var a int
			for i := 0; i < mods; i++ {
				a++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *int { return new(int) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]int{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]int, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[int]int)
			for i := 0; i < length; i++ {
				a[int(i)] = int(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*int]int)
			for i := 0; i < length; i++ {
				a[new(int)] = int(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan int)
			for i := 0; i < mods; i++ {
				go func() { a <- int(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(int(0))
			for i := 0; i < mods; i++ {
				a = a.(int) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "uintptr",
		t: func() {
			var a uintptr
			for i := 0; i < mods; i++ {
				a++
				runtime.Gosched()
			}
		},
		pointerT: func() {
			a := func() *uintptr { return new(uintptr) }()
			for i := 0; i < mods; i++ {
				*a++
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]uintptr{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]uintptr, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j]++
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[uintptr]uintptr)
			for i := 0; i < length; i++ {
				a[uintptr(i)] = uintptr(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*uintptr]uintptr)
			for i := 0; i < length; i++ {
				a[new(uintptr)] = uintptr(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k]++
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan uintptr)
			for i := 0; i < mods; i++ {
				go func() { a <- uintptr(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(uintptr(0))
			for i := 0; i < mods; i++ {
				a = a.(uintptr) + 1
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "string",
		t: func() {
			var s string
			f := func(a string) string { return a }
			for i := 0; i < mods; i++ {
				s = str(i)
				s = f(s)
			}
		},
		pointerT: func() {
			a := func() *string { return new(string) }()
			for i := 0; i < mods; i++ {
				*a = str(i)
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]string{}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] = str(i)
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]string, length)
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j] = str(i)
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[string]string)
			for i := 0; i < length; i++ {
				a[string(i)] = str(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] = str(i)
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*string]string)
			for i := 0; i < length; i++ {
				a[new(string)] = str(i)
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for k, _ := range a {
					a[k] = str(i)
					runtime.Gosched()
				}
			}
		},
		chanT: func() {
			a := make(chan string)
			for i := 0; i < mods; i++ {
				go func() { a <- str(i) }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(str(0))
			f := func(a string) string { return a }
			for i := 0; i < mods; i++ {
				a = str(i)
				a = f(a.(string))
				runtime.Gosched()
			}
		},
	},
	modifier{
		name: "structT",
		t: func() {
			s := newStructT()
			for i := 0; i < mods; i++ {
				s.u8++
				s.u16++
				s.u32++
				s.u64++
				s.i8++
				s.i16++
				s.i32++
				s.i64++
				s.f32 *= 1.01
				s.f64 *= 1.01
				s.c64 = complex(real(s.c64)*1.01, imag(s.c64)*1.01)
				s.c128 = complex(real(s.c128)*1.01, imag(s.c128)*1.01)
				s.b++
				s.r++
				s.u++
				s.in++
				s.uip++
				s.s = str(i)
				runtime.Gosched()
			}
		},
		pointerT: func() {
			s := func() *structT {
				t := newStructT()
				return &t
			}()
			for i := 0; i < mods; i++ {
				s.u8++
				s.u16++
				s.u32++
				s.u64++
				s.i8++
				s.i16++
				s.i32++
				s.i64++
				s.f32 *= 1.01
				s.f64 *= 1.01
				s.c64 = complex(real(s.c64)*1.01, imag(s.c64)*1.01)
				s.c128 = complex(real(s.c128)*1.01, imag(s.c128)*1.01)
				s.b++
				s.r++
				s.u++
				s.in++
				s.uip++
				s.s = str(i)
				runtime.Gosched()
			}
		},
		arrayT: func() {
			a := [length]structT{}
			for i := 0; i < len(a); i++ {
				a[i] = newStructT()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j].u8++
					a[j].u16++
					a[j].u32++
					a[j].u64++
					a[j].i8++
					a[j].i16++
					a[j].i32++
					a[j].i64++
					a[j].f32 *= 1.01
					a[j].f64 *= 1.01
					a[j].c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
					a[j].c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
					a[j].b++
					a[j].r++
					a[j].u++
					a[j].in++
					a[j].uip++
					a[j].s = str(i)
					runtime.Gosched()
				}
			}
		},
		sliceT: func() {
			a := make([]structT, length)
			for i := 0; i < len(a); i++ {
				a[i] = newStructT()
			}
			for i := 0; i < mods; i++ {
				for j := 0; j < len(a); j++ {
					a[j].u8++
					a[j].u16++
					a[j].u32++
					a[j].u64++
					a[j].i8++
					a[j].i16++
					a[j].i32++
					a[j].i64++
					a[j].f32 *= 1.01
					a[j].f64 *= 1.01
					a[j].c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
					a[j].c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
					a[j].b++
					a[j].r++
					a[j].u++
					a[j].in++
					a[j].uip++
					a[j].s = str(i)
					runtime.Gosched()
				}
			}
		},
		mapT: func() {
			a := make(map[structT]structT)
			for i := 0; i < length; i++ {
				m := newStructT()
				m.in = i
				a[m] = newStructT()
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j, _ := range a {
					m := a[j]
					m.u8++
					m.u16++
					m.u32++
					m.u64++
					m.i8++
					m.i16++
					m.i32++
					m.i64++
					m.f32 *= 1.01
					m.f64 *= 1.01
					m.c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
					m.c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
					m.b++
					m.r++
					m.u++
					m.in++
					m.uip++
					m.s = str(i)
					a[j] = m
					runtime.Gosched()
				}
				runtime.Gosched()
			}
		},
		mapPointerKeyT: func() {
			a := make(map[*structT]structT)
			f := func() *structT {
				m := newStructT()
				return &m
			}
			for i := 0; i < length; i++ {
				m := f()
				m.in = i
				a[m] = newStructT()
				runtime.Gosched()
			}
			for i := 0; i < mods; i++ {
				for j, _ := range a {
					m := a[j]
					m.u8++
					m.u16++
					m.u32++
					m.u64++
					m.i8++
					m.i16++
					m.i32++
					m.i64++
					m.f32 *= 1.01
					m.f64 *= 1.01
					m.c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
					m.c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
					m.b++
					m.r++
					m.u++
					m.in++
					m.uip++
					m.s = str(i)
					a[j] = m
					runtime.Gosched()
				}
				runtime.Gosched()
			}
		},
		chanT: func() {
			a := make(chan structT)
			for i := 0; i < mods; i++ {
				go func() { a <- newStructT() }()
				<-a
				runtime.Gosched()
			}
		},
		interfaceT: func() {
			a := interface{}(newStructT())
			for i := 0; i < mods; i++ {
				a = a.(structT)
				runtime.Gosched()
			}
		},
	},
}

type structT struct {
	u8   uint8
	u16  uint16
	u32  uint32
	u64  uint64
	i8   int8
	i16  int16
	i32  int32
	i64  int64
	f32  float32
	f64  float64
	c64  complex64
	c128 complex128
	b    byte
	r    rune
	u    uint
	in   int
	uip  uintptr
	s    string
}

func newStructT() structT {
	return structT{
		f32:  1.01,
		f64:  1.01,
		c64:  complex(float32(1.01), float32(1.01)),
		c128: complex(float64(1.01), float64(1.01)),
	}
}

func str(in int) string {
	switch in % 3 {
	case 0:
		return "Hello"
	case 1:
		return "world"
	case 2:
		return "!"
	}
	return "?"
}