{*ast.File [storage]}


{*ast.GenDecl -> *ast.ImportSpec -> *ast.BasicLit [STRING "fmt"]}
{*ast.ImportSpec -> *ast.BasicLit [STRING "reflect"]}
{*ast.ImportSpec -> *ast.BasicLit [STRING "sync"]}
{*ast.ImportSpec -> *ast.BasicLit [STRING "unsafe"]}
{*ast.ImportSpec -> *ast.BasicLit [STRING "github.com/pkg/errors"]}
{*ast.ImportSpec -> *ast.BasicLit [STRING "gorgonia.org/tensor/internal/storage"]}
{*ast.GenDecl -> *ast.TypeSpec [array]}
{*ast.StructType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr [storage Header]}
{*ast.Field [t Dtype]}


function name is makeArray 
	 { [makeArray]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [t Dtype]}
	 {*ast.Field [length int]}
	 {*ast.FieldList -> *ast.Field [array]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= v]}
	 {*ast.CallExpr [malloc t length]}
	 {*ast.AssignStmt [:= hdr]}
	 {*ast.CompositeLit -> *ast.SelectorExpr [storage Header]}
	 {*ast.KeyValueExpr [Raw v]}
	 {*ast.ReturnStmt -> *ast.CompositeLit [array]}
	 {*ast.KeyValueExpr [Header hdr]}
	 {*ast.KeyValueExpr [t t]}


function name is arrayFromSlice 
	 { [arrayFromSlice]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [x]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.FieldList -> *ast.Field [array]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= xT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect TypeOf x]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.CallExpr -> *ast.SelectorExpr [xT Kind]}
	 {*ast.SelectorExpr [reflect Slice]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Expected a slice"]}
	 {*ast.AssignStmt [:= elT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [xT Elem]}
	 {*ast.ReturnStmt -> *ast.CompositeLit [array]}
	 {*ast.KeyValueExpr [Header]}
	 {*ast.CompositeLit -> *ast.SelectorExpr [storage Header]}
	 {*ast.KeyValueExpr [Raw]}
	 {*ast.CallExpr -> *ast.SelectorExpr [storage AsByteSlice x]}
	 {*ast.KeyValueExpr [t]}
	 {*ast.CompositeLit [Dtype elT]}


function name is Len 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array Len]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a Header TypedLen]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a t Type]}


function name is Cap 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array Cap]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a Header TypedLen]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a t Type]}


function name is fromSlice 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array fromSlice]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [x]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.BlockStmt -> *ast.AssignStmt [:= xT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect TypeOf x]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.CallExpr -> *ast.SelectorExpr [xT Kind]}
	 {*ast.SelectorExpr [reflect Slice]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Expected a slice"]}
	 {*ast.AssignStmt [:= elT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [xT Elem]}
	 {*ast.AssignStmt [=]}
	 {*ast.SelectorExpr [a Raw]}
	 {*ast.CallExpr -> *ast.SelectorExpr [storage AsByteSlice x]}
	 {*ast.AssignStmt [=]}
	 {*ast.SelectorExpr [a t]}
	 {*ast.CompositeLit [Dtype elT]}


function name is fromSliceOrArrayer 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array fromSliceOrArrayer]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [x]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.BlockStmt -> *ast.IfStmt -> *ast.AssignStmt [:= T ok]}
	 {*ast.TypeAssertExpr [x arrayer ok]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= xp]}
	 {*ast.CallExpr -> *ast.SelectorExpr [T arrPtr]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [==]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw nil]}
	 {*ast.BlockStmt -> *ast.AssignStmt [=]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw]}
	 {*ast.CallExpr [malloc]}
	 {*ast.SelectorExpr [xp t]}
	 {*ast.CallExpr -> *ast.SelectorExpr [xp Len]}
	 {*ast.AssignStmt [=]}
	 {*ast.SelectorExpr [a t]}
	 {*ast.SelectorExpr [xp t]}
	 {*ast.ExprStmt -> *ast.CallExpr [copyArray a]}
	 {*ast.CallExpr -> *ast.SelectorExpr [T arrPtr]}
	 {*ast.ReturnStmt -> *ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [a fromSlice x]}


function name is byteSlice 
	 {*ast.FieldList -> *ast.Field [a array byteSlice]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.ArrayType [byte]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw]}


function name is sliceInto 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array sliceInto]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [i j int]}
	 {*ast.Field [res]}
	 {*ast.StarExpr [array]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= c]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Cap]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [||]}
	 {*ast.BinaryExpr [||]}
	 {*ast.BinaryExpr [< i]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.BinaryExpr [< j i]}
	 {*ast.BinaryExpr [> j c]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.CallExpr -> *ast.SelectorExpr [fmt Sprintf]}
	 {*ast.BasicLit [STRING "Cannot slice %v - index %d:%d is out of bounds"]}
	 { [a i j]}
	 {*ast.AssignStmt [:= s]}
	 {*ast.BinaryExpr [* i]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.AssignStmt [:= e]}
	 {*ast.BinaryExpr [* j]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.AssignStmt [= c]}
	 {*ast.BinaryExpr [- c i]}
	 {*ast.AssignStmt [=]}
	 {*ast.SelectorExpr [res Raw]}
	 {*ast.SliceExpr -> *ast.SelectorExpr [a Raw s e]}


function name is slice 
	 {*ast.FieldList -> *ast.Field [a array slice]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [start end int]}
	 {*ast.FieldList -> *ast.Field [array]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [> end]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Len]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Index out of range"]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [< end start]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Index out of range"]}
	 {*ast.AssignStmt [:= s]}
	 {*ast.BinaryExpr [* start]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.AssignStmt [:= e]}
	 {*ast.BinaryExpr [* end]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.ReturnStmt -> *ast.CompositeLit [array]}
	 {*ast.KeyValueExpr [Header]}
	 {*ast.CompositeLit -> *ast.SelectorExpr [storage Header]}
	 {*ast.KeyValueExpr [Raw]}
	 {*ast.SliceExpr -> *ast.SelectorExpr [a Raw s e]}
	 {*ast.KeyValueExpr [t]}
	 {*ast.SelectorExpr [a t]}


function name is swap 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array swap]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [i j int]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [==]}
	 {*ast.SelectorExpr [a t String]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= ss]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [a hdr Strings]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [ss i]}
	 {*ast.IndexExpr [ss j]}
	 {*ast.IndexExpr [ss j]}
	 {*ast.IndexExpr [ss i]}
	 {*ast.ReturnStmt -> *ast.IfStmt []}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr [isParameterizedKind]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Kind]}
	 {*ast.BlockStmt []}
	 {*ast.SwitchStmt -> *ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.BlockStmt []}
	 {*ast.CaseClause -> *ast.BasicLit [INT 8]}
	 {*ast.AssignStmt [:= us]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [a hdr Uint64s]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [us i]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us i]}
	 {*ast.CaseClause -> *ast.BasicLit [INT 4]}
	 {*ast.AssignStmt [:= us]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [a hdr Uint32s]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [us i]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us i]}
	 {*ast.CaseClause -> *ast.BasicLit [INT 2]}
	 {*ast.AssignStmt [:= us]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [a hdr Uint16s]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [us i]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us i]}
	 {*ast.CaseClause -> *ast.BasicLit [INT 1]}
	 {*ast.AssignStmt [:= us]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [a hdr Uint8s]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [us i]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us j]}
	 {*ast.IndexExpr [us i]}
	 {*ast.ReturnStmt -> *ast.AssignStmt [:= size]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.AssignStmt [:= tmp]}
	 {*ast.CallExpr [make]}
	 {*ast.ArrayType [byte size]}
	 {*ast.AssignStmt [:= bs]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a byteSlice]}
	 {*ast.AssignStmt [:= is]}
	 {*ast.BinaryExpr [* i size]}
	 {*ast.AssignStmt [:= ie]}
	 {*ast.BinaryExpr [+ is size]}
	 {*ast.AssignStmt [:= js]}
	 {*ast.BinaryExpr [* j size]}
	 {*ast.AssignStmt [:= je]}
	 {*ast.BinaryExpr [+ js size]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy tmp]}
	 {*ast.SliceExpr [bs is ie]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy]}
	 {*ast.SliceExpr [bs is ie]}
	 {*ast.SliceExpr [bs js je]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy]}
	 {*ast.SliceExpr [bs js je tmp]}


function name is Uintptr 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array Uintptr]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field [uintptr]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr [uintptr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [unsafe Pointer]}
	 {*ast.UnaryExpr [&]}
	 {*ast.IndexExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw]}
	 {*ast.BasicLit [INT 0]}


function name is MemSize 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array MemSize]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field [uintptr]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr [uintptr]}
	 {*ast.CallExpr [len]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw]}


function name is Data 
	 {*ast.FieldList -> *ast.Field [a array Data]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.InterfaceType []}
	 {*ast.FieldList -> *ast.BlockStmt -> *ast.AssignStmt [:= shdr]}
	 {*ast.CompositeLit -> *ast.SelectorExpr [reflect SliceHeader]}
	 {*ast.KeyValueExpr [Data]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Uintptr]}
	 {*ast.KeyValueExpr [Len]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Len]}
	 {*ast.KeyValueExpr [Cap]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Cap]}
	 {*ast.AssignStmt [:= sliceT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect SliceOf]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a t Type]}
	 {*ast.AssignStmt [:= ptr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [unsafe Pointer]}
	 {*ast.UnaryExpr [& shdr]}
	 {*ast.AssignStmt [:= val]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect Indirect]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect NewAt sliceT ptr]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [val Interface]}


function name is Zero 
	 {*ast.FieldList -> *ast.Field [a array Zero]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [==]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Kind]}
	 {*ast.SelectorExpr [reflect String]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= ss]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Strings]}
	 {*ast.RangeStmt [i ss]}
	 {*ast.BlockStmt -> *ast.AssignStmt [=]}
	 {*ast.IndexExpr [ss i]}
	 {*ast.BasicLit [STRING ""]}
	 {*ast.ReturnStmt -> *ast.IfStmt []}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr [isParameterizedKind]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Kind]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= ba]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a byteSlice]}
	 {*ast.RangeStmt [i ba]}
	 {*ast.BlockStmt -> *ast.AssignStmt [=]}
	 {*ast.IndexExpr [ba i]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.ReturnStmt -> *ast.AssignStmt [:= l]}
	 {*ast.CallExpr -> *ast.SelectorExpr [a Len]}
	 {*ast.ForStmt -> *ast.AssignStmt [:= i]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.BinaryExpr [< i l]}
	 {*ast.IncDecStmt [i]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= val]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect NewAt]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [a t Type]}
	 {*ast.CallExpr -> *ast.SelectorExpr [storage ElementAt i]}
	 {*ast.CallExpr -> *ast.SelectorExpr [unsafe Pointer]}
	 {*ast.UnaryExpr [&]}
	 {*ast.IndexExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a Header Raw]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Size]}
	 {*ast.AssignStmt [= val]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect Indirect val]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [val Set]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect Zero]}
	 {*ast.SelectorExpr [a t]}


function name is hdr 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array hdr]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.StarExpr -> *ast.SelectorExpr [storage Header]}
	 {*ast.BlockStmt -> *ast.ReturnStmt []}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [a Header]}


function name is rtype 
	 {*ast.FieldList -> *ast.Field [a]}
	 {*ast.StarExpr [array rtype]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr [reflect Type]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.SelectorExpr -> *ast.SelectorExpr [a t Type]}


function name is malloc 
	 { [malloc]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [t Dtype]}
	 {*ast.Field [length int]}
	 {*ast.FieldList -> *ast.Field -> *ast.ArrayType [byte]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= size]}
	 {*ast.CallExpr [int]}
	 {*ast.CallExpr [calcMemSize t length]}
	 {*ast.ReturnStmt -> *ast.CallExpr [make]}
	 {*ast.ArrayType [byte size]}


function name is calcMemSize 
	 { [calcMemSize]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dt Dtype]}
	 {*ast.Field [size int]}
	 {*ast.FieldList -> *ast.Field [int64]}
	 {*ast.BlockStmt -> *ast.ReturnStmt []}
	 {*ast.BinaryExpr [*]}
	 {*ast.CallExpr [int64]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dt Size]}
	 {*ast.CallExpr [int64 size]}


function name is copyArray 
	 { [copyArray]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dst src]}
	 {*ast.StarExpr [array]}
	 {*ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.SelectorExpr [dst t]}
	 {*ast.SelectorExpr [src t]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Cannot copy arrays of different types."]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [storage Copy]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [dst t Type]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [dst Header]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [src Header]}


function name is copyArraySliced 
	 { [copyArraySliced]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dst array]}
	 {*ast.Field [dstart dend int]}
	 {*ast.Field [src array]}
	 {*ast.Field [sstart send int]}
	 {*ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.SelectorExpr [dst t]}
	 {*ast.SelectorExpr [src t]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Cannot copy arrays of different types."]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [storage CopySliced]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [dst t Type]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [dst Header dstart dend]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [src Header sstart send]}


function name is copyDense 
	 { [copyDense]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dst src DenseTensor]}
	 {*ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst Dtype]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src Dtype]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Cannot dopy DenseTensors of different types"]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= ms ok]}
	 {*ast.TypeAssertExpr [src MaskedTensor]}
	 {*ast.BinaryExpr [&& ok]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms IsMasked]}
	 {*ast.BlockStmt -> *ast.IfStmt -> *ast.AssignStmt [:= md ok]}
	 {*ast.TypeAssertExpr [dst MaskedTensor ok]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.AssignStmt [:= smask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms Mask]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [<]}
	 {*ast.CallExpr [cap dmask]}
	 {*ast.CallExpr [len smask]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= dmask]}
	 {*ast.CallExpr [make]}
	 {*ast.ArrayType [bool]}
	 {*ast.CallExpr [len smask]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [md SetMask dmask]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy dmask smask]}
	 {*ast.AssignStmt [:= e]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src Engine]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= err]}
	 {*ast.CallExpr -> *ast.SelectorExpr [e Memcpy]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst arrPtr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src arrPtr]}
	 {*ast.BinaryExpr [!= err nil]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic err]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [dst len]}


function name is copyDenseSliced 
	 { [copyDenseSliced]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dst DenseTensor]}
	 {*ast.Field [dstart dend int]}
	 {*ast.Field [src DenseTensor]}
	 {*ast.Field [sstart send int]}
	 {*ast.FieldList -> *ast.Field [int]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst Dtype]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src Dtype]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Cannot copy DenseTensors of different types"]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= ms ok]}
	 {*ast.TypeAssertExpr [src MaskedTensor]}
	 {*ast.BinaryExpr [&& ok]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms IsMasked]}
	 {*ast.BlockStmt -> *ast.IfStmt -> *ast.AssignStmt [:= md ok]}
	 {*ast.TypeAssertExpr [dst MaskedTensor ok]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.AssignStmt [:= smask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms Mask]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [<]}
	 {*ast.CallExpr [cap dmask dend]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= dmask]}
	 {*ast.CallExpr [make]}
	 {*ast.ArrayType [bool dend]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [md SetMask dmask]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy]}
	 {*ast.SliceExpr [dmask dstart dend]}
	 {*ast.SliceExpr [smask sstart send]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= e]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src Engine]}
	 {*ast.BinaryExpr [!= e nil]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= darr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst arr]}
	 {*ast.AssignStmt [:= sarr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src arr]}
	 {*ast.AssignStmt [:= da]}
	 {*ast.CallExpr -> *ast.SelectorExpr [darr slice dstart dend]}
	 {*ast.AssignStmt [:= sa]}
	 {*ast.CallExpr -> *ast.SelectorExpr [sarr slice sstart send]}
	 {*ast.TypeSwitchStmt -> *ast.ExprStmt -> *ast.TypeAssertExpr [e]}
	 {*ast.BlockStmt []}
	 {*ast.CaseClause [NonStdEngine]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= err]}
	 {*ast.CallExpr -> *ast.SelectorExpr [e Memcpy]}
	 {*ast.UnaryExpr [& da]}
	 {*ast.UnaryExpr [& sa]}
	 {*ast.BinaryExpr [!= err nil]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic err]}
	 {*ast.CaseClause -> *ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [storage Copy]}
	 {*ast.SelectorExpr -> *ast.SelectorExpr [da t Type]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [da Header]}
	 {*ast.UnaryExpr [&]}
	 {*ast.SelectorExpr [sa Header]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [da Len]}
	 {*ast.ReturnStmt -> *ast.CallExpr [copyArraySliced]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst arr dstart dend]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src arr sstart send]}


function name is copyDenseIter 
	 { [copyDenseIter]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [dst src DenseTensor]}
	 {*ast.Field [diter siter Iterator]}
	 {*ast.FieldList -> *ast.Field [int]}
	 {*ast.Field [error]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [!=]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst Dtype]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src Dtype]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [panic]}
	 {*ast.BasicLit [STRING "Cannot copy Dense arrays of different types"]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [&&]}
	 {*ast.BinaryExpr [&&]}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst RequiresIterator]}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src RequiresIterator]}
	 {*ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [dst DataOrder HasSameOrder]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src DataOrder]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr [copyDense dst src nil]}
	 {*ast.IfStmt []}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst IsNativelyAccessible]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.BasicLit [INT 0]}
	 {*ast.CallExpr -> *ast.SelectorExpr [errors Errorf inaccessibleData dst]}
	 {*ast.IfStmt []}
	 {*ast.UnaryExpr [!]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src IsNativelyAccessible]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.BasicLit [INT 0]}
	 {*ast.CallExpr -> *ast.SelectorExpr [errors Errorf inaccessibleData src]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [== diter nil]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= diter]}
	 {*ast.CallExpr [FlatIteratorFromDense dst]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [== siter nil]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= siter]}
	 {*ast.CallExpr [FlatIteratorFromDense src]}
	 {*ast.IfStmt -> *ast.AssignStmt [:= ms ok]}
	 {*ast.TypeAssertExpr [src MaskedTensor]}
	 {*ast.BinaryExpr [&& ok]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms IsMasked]}
	 {*ast.BlockStmt -> *ast.IfStmt -> *ast.AssignStmt [:= md ok]}
	 {*ast.TypeAssertExpr [dst MaskedTensor ok]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.AssignStmt [:= smask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [ms Mask]}
	 {*ast.IfStmt []}
	 {*ast.BinaryExpr [<]}
	 {*ast.CallExpr [cap dmask]}
	 {*ast.CallExpr [len smask]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= dmask]}
	 {*ast.CallExpr [make]}
	 {*ast.ArrayType [bool]}
	 {*ast.CallExpr [len smask]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy dmask]}
	 {*ast.CallExpr -> *ast.SelectorExpr [md Mask]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [md SetMask dmask]}
	 {*ast.ExprStmt -> *ast.CallExpr [copy dmask smask]}
	 {*ast.ReturnStmt -> *ast.CallExpr -> *ast.SelectorExpr [storage CopyIter]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst rtype]}
	 {*ast.CallExpr -> *ast.SelectorExpr [dst hdr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [src hdr diter siter nil]}


{*ast.GenDecl -> *ast.TypeSpec [scalarPtrCount]}
{*ast.StructType -> *ast.FieldList -> *ast.Field -> *ast.SelectorExpr [Ptr unsafe Pointer]}
{*ast.Field [Count int]}


{*ast.GenDecl -> *ast.ValueSpec [scalarRCLock]}
{*ast.SelectorExpr [sync Mutex]}


{*ast.GenDecl -> *ast.ValueSpec [scalarRC]}
{*ast.CallExpr [make]}
{*ast.MapType [uintptr]}
{*ast.StarExpr -> *ast.SelectorExpr [sync Pool]}


function name is scalarPool 
	 { [scalarPool]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [size uintptr]}
	 {*ast.FieldList -> *ast.Field -> *ast.StarExpr -> *ast.SelectorExpr [sync Pool]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [scalarRCLock Lock]}
	 {*ast.AssignStmt [:= pool ok]}
	 {*ast.IndexExpr [scalarRC size]}
	 {*ast.IfStmt []}
	 {*ast.UnaryExpr [! ok]}
	 {*ast.BlockStmt -> *ast.AssignStmt [= pool]}
	 {*ast.UnaryExpr [&]}
	 {*ast.CompositeLit -> *ast.SelectorExpr [sync Pool]}
	 {*ast.KeyValueExpr [New]}
	 {*ast.FuncLit -> *ast.FuncType -> *ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.InterfaceType []}
	 {*ast.FieldList -> *ast.BlockStmt -> *ast.ReturnStmt -> *ast.CallExpr [make]}
	 {*ast.ArrayType [byte size]}
	 {*ast.AssignStmt [=]}
	 {*ast.IndexExpr [scalarRC size pool]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [scalarRCLock Unlock]}
	 {*ast.ReturnStmt [pool]}


function name is allocScalar 
	 { [allocScalar]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [a]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.FieldList -> *ast.Field -> *ast.ArrayType [byte]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= atype]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect TypeOf a]}
	 {*ast.AssignStmt [:= size]}
	 {*ast.CallExpr -> *ast.SelectorExpr [atype Size]}
	 {*ast.AssignStmt [:= pool]}
	 {*ast.CallExpr [scalarPool size]}
	 {*ast.ReturnStmt -> *ast.TypeAssertExpr -> *ast.CallExpr -> *ast.SelectorExpr [pool Get]}
	 {*ast.ArrayType [byte]}


function name is freeScalar 
	 { [freeScalar]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [bs]}
	 {*ast.ArrayType [byte]}
	 {*ast.BlockStmt -> *ast.IfStmt []}
	 {*ast.BinaryExpr [== bs nil]}
	 {*ast.BlockStmt -> *ast.ReturnStmt -> *ast.RangeStmt [i bs]}
	 {*ast.BlockStmt -> *ast.AssignStmt [=]}
	 {*ast.IndexExpr [bs i]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.AssignStmt [:= size]}
	 {*ast.CallExpr [uintptr]}
	 {*ast.CallExpr [len bs]}
	 {*ast.AssignStmt [:= pool]}
	 {*ast.CallExpr [scalarPool size]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr [pool Put bs]}


function name is scalarToHeader 
	 { [scalarToHeader]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [a]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.FieldList -> *ast.Field [hdr]}
	 {*ast.StarExpr -> *ast.SelectorExpr [storage Header]}
	 {*ast.Field [newAlloc bool]}
	 {*ast.BlockStmt -> *ast.GenDecl -> *ast.ValueSpec [raw]}
	 {*ast.ArrayType [byte]}
	 {*ast.TypeSwitchStmt -> *ast.AssignStmt [:= at]}
	 {*ast.TypeAssertExpr [a]}
	 {*ast.BlockStmt []}
	 {*ast.CaseClause [Memory]}
	 {*ast.AssignStmt [= raw]}
	 {*ast.CallExpr -> *ast.SelectorExpr [storage FromMemory]}
	 {*ast.CallExpr -> *ast.SelectorExpr [at Uintptr]}
	 {*ast.CallExpr -> *ast.SelectorExpr [at MemSize]}
	 {*ast.CaseClause -> *ast.AssignStmt [= raw]}
	 {*ast.CallExpr [allocScalar a]}
	 {*ast.AssignStmt [= newAlloc true]}
	 {*ast.AssignStmt [= hdr]}
	 {*ast.CallExpr [borrowHeader]}
	 {*ast.AssignStmt [=]}
	 {*ast.SelectorExpr [hdr Raw raw]}
	 {*ast.IfStmt [newAlloc]}
	 {*ast.BlockStmt -> *ast.ExprStmt -> *ast.CallExpr [copyScalarToPrealloc a]}
	 {*ast.SelectorExpr [hdr Raw]}
	 {*ast.ReturnStmt [hdr newAlloc]}


function name is copyScalarToPrealloc 
	 { [copyScalarToPrealloc]}
	 {*ast.FuncType -> *ast.FieldList -> *ast.Field [a]}
	 {*ast.InterfaceType []}
	 {*ast.FieldList -> *ast.Field [bs]}
	 {*ast.ArrayType [byte]}
	 {*ast.BlockStmt -> *ast.AssignStmt [:= xV]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect ValueOf a]}
	 {*ast.AssignStmt [:= xT]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect TypeOf a]}
	 {*ast.AssignStmt [:= p]}
	 {*ast.CallExpr -> *ast.SelectorExpr [unsafe Pointer]}
	 {*ast.UnaryExpr [&]}
	 {*ast.IndexExpr [bs]}
	 {*ast.BasicLit [INT 0]}
	 {*ast.AssignStmt [:= v]}
	 {*ast.CallExpr -> *ast.SelectorExpr [reflect NewAt xT p]}
	 {*ast.ExprStmt -> *ast.CallExpr -> *ast.SelectorExpr -> *ast.CallExpr -> *ast.SelectorExpr [reflect Indirect v Set xV]}
	 {*ast.ReturnStmt []}


