function name: Map
   0.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Bool f0 bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Bools]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as != f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as == f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! as]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrB f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapB f0 at]
   1.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Int f0 int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Ints]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp int]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrI f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrI f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrI f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapI f0 at]
   2.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Int8 f0 int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Int8s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp int8]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrI8 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrI8 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrI8 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapI8 f0 at]
   3.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Int16 f0 int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Int16s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp int16]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrI16 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrI16 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrI16 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapI16 f0 at]
   4.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Int32 f0 int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Int32s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp int32]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrI32 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrI32 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrI32 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapI32 f0 at]
   5.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Int64 f0 int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Int64s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp int64]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrI64 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrI64 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrI64 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapI64 f0 at]
   6.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uint f0 uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uints]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp uint]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrU f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrU f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrU f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapU f0 at]
   7.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uint8 f0 uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uint8s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp uint8]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrU8 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrU8 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrU8 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapU8 f0 at]
   8.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uint16 f0 uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uint16s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp uint16]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrU16 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrU16 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrU16 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapU16 f0 at]
   9.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uint32 f0 uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uint32s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp uint32]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrU32 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrU32 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrU32 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapU32 f0 at]
   10.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uint64 f0 uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uint64s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp uint64]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrU64 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrU64 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrU64 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapU64 f0 at]
   11.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Uintptr f0 uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Uintptrs]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as != f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as == f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! as]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrUintptr f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapUintptr f0 at]
   12.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Float32 f0 float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Float32s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp float32]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrF32 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrF32 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrF32 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapF32 f0 at]
   13.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Float64 f0 float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Float64s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp float64]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrF64 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrF64 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrF64 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapF64 f0 at]
   14.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Complex64 f0 complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Complex64s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp complex64]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrC64 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrC64 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrC64 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapC64 f0 at]
   15.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [Complex128 f0 complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Complex128s]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp complex128]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrC128 f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrC128 f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrC128 f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapC128 f0 at]
   16.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [String f0 string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a Strings]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& && as incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec 	 [tmp string]
     *ast.IfStmt -> *ast.AssignStmt -> *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [= tmp err f1 at INT 0]
     *ast.BinaryExpr 	 [!= err nil]
     *ast.BlockStmt -> *ast.ReturnStmt 	 []
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [+= at INT 0]
      	 [tmp]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && as ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [!= f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIncrStr f0 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
      	 [incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIncrErrStr f1 at]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& && ! as]
     *ast.UnaryExpr 	 [! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrStr f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapStr f0 at]
   17.case
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [UnsafePointer f0 unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [f1 unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [:= at a UnsafePointers]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as != f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [f0 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& as == f0 nil]
     *ast.AssignStmt -> *ast.IndexExpr -> *ast.BasicLit 	 [= at INT 0]
     *ast.CallExpr -> *ast.IndexExpr -> *ast.BasicLit 	 [err f1 at INT 0]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! as]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapErrUnsafePointer f1 at]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapUnsafePointer f0 at]

function name: MapIter
   0.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Bool := at a Bools]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [bool]
     *ast.FieldList -> *ast.Field 	 [bool]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrB f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterB f0 at ait]
   1.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Int := at a Ints]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int]
     *ast.FieldList -> *ast.Field 	 [int]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrI f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrI f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrI f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterI f0 at ait]
   2.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Int8 := at a Int8s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int8]
     *ast.FieldList -> *ast.Field 	 [int8]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrI8 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrI8 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrI8 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterI8 f0 at ait]
   3.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Int16 := at a Int16s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int16]
     *ast.FieldList -> *ast.Field 	 [int16]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrI16 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrI16 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrI16 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterI16 f0 at ait]
   4.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Int32 := at a Int32s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int32]
     *ast.FieldList -> *ast.Field 	 [int32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrI32 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrI32 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrI32 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterI32 f0 at ait]
   5.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Int64 := at a Int64s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [int64]
     *ast.FieldList -> *ast.Field 	 [int64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrI64 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrI64 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrI64 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterI64 f0 at ait]
   6.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uint := at a Uints]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint]
     *ast.FieldList -> *ast.Field 	 [uint]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrU f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrU f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrU f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterU f0 at ait]
   7.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uint8 := at a Uint8s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.FieldList -> *ast.Field 	 [uint8]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrU8 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrU8 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrU8 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterU8 f0 at ait]
   8.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uint16 := at a Uint16s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.FieldList -> *ast.Field 	 [uint16]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrU16 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrU16 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrU16 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterU16 f0 at ait]
   9.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uint32 := at a Uint32s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.FieldList -> *ast.Field 	 [uint32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrU32 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrU32 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrU32 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterU32 f0 at ait]
   10.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uint64 := at a Uint64s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.FieldList -> *ast.Field 	 [uint64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrU64 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrU64 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrU64 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterU64 f0 at ait]
   11.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Uintptr := at a Uintptrs]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.FieldList -> *ast.Field 	 [uintptr]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrUintptr f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterUintptr f0 at ait]
   12.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Float32 := at a Float32s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float32]
     *ast.FieldList -> *ast.Field 	 [float32]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrF32 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrF32 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrF32 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterF32 f0 at ait]
   13.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Float64 := at a Float64s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [float64]
     *ast.FieldList -> *ast.Field 	 [float64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrF64 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrF64 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrF64 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterF64 f0 at ait]
   14.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Complex64 := at a Complex64s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.FieldList -> *ast.Field 	 [complex64]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrC64 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrC64 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrC64 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterC64 f0 at ait]
   15.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [Complex128 := at a Complex128s]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.FieldList -> *ast.Field 	 [complex128]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrC128 f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrC128 f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrC128 f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterC128 f0 at ait]
   16.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [String := at a Strings]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f0 string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [f1 string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field 	 [string]
     *ast.FieldList -> *ast.Field 	 [string]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr != f0 nil]
     *ast.ExprStmt -> *ast.CallExpr 	 [MapIterIncrStr f0 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.BinaryExpr 	 [&& incr == f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterIncrErrStr f1 at ait]
     *ast.CaseClause -> *ast.BinaryExpr -> *ast.UnaryExpr 	 [&& ! incr]
     *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrStr f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterStr f0 at ait]
   17.case
     *ast.AssignStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [UnsafePointer := at a UnsafePointers]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [f0 unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.DeclStmt -> *ast.GenDecl -> *ast.ValueSpec -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [f1 unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.Field 	 [error]
     *ast.TypeSwitchStmt -> *ast.AssignStmt -> *ast.TypeAssertExpr 	 [:= f fn]
     *ast.BlockStmt -> *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.AssignStmt 	 [= f0 f]
     *ast.CaseClause -> *ast.FuncType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.FieldList -> *ast.Field -> *ast.SelectorExpr 	 [unsafe Pointer]
     *ast.Field 	 [error]
     *ast.AssignStmt 	 [= f1 f]
     *ast.CaseClause -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [default errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot map fn of %T to array" fn]
     *ast.IfStmt -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr 	 [incr errors Errorf]
     *ast.BasicLit 	 [STRING "Cannot perform increment on t of %v" t]
     *ast.SwitchStmt -> *ast.BlockStmt -> *ast.CaseClause -> *ast.BinaryExpr 	 [== f0 nil]
     *ast.AssignStmt -> *ast.CallExpr 	 [= err MapIterErrUnsafePointer f1 at ait]
     *ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr 	 [default MapIterUnsafePointer f0 at ait]

