func NumCgoCall() int64 {
	return 0
}
We fake a cgo environment to catch errors. Therefor we have to implement this and always return 0
package runtime
import (
	"runtime/internal/sys"
	"github.com/gopherjs/gopherjs/js"
)
const GOOS = sys.GOOS
const GOARCH = "js"
const Compiler = "gopherjs"
type Error interface {
	error
	RuntimeError()
}
type _type struct{ str string }
func (t *_type) string() string  { return t.str }
func (t *_type) pkgpath() string { return "" }
type TypeAssertionError struct {
	_interface    *_type
	concrete      *_type
	asserted      *_type
	missingMethod string  
}
func (*TypeAssertionError) RuntimeError() {}
func (e *TypeAssertionError) Error() string {
	inter := "interface"
	if e._interface != nil {
		inter = e._interface.string()
	}
	as := e.asserted.string()
	if e.concrete == nil {
		return "interface conversion: " + inter + " is nil, not " + as
	}
	cs := e.concrete.string()
	if e.missingMethod == "" {
		msg := "interface conversion: " + inter + " is " + cs + ", not " + as
		if cs == as {
			if e.concrete.pkgpath() != e.asserted.pkgpath() {
				msg += " (types from different packages)"
			} else {
				msg += " (types from different scopes)"
			}
		}
		return msg
	}
	return "interface conversion: " + cs + " is not " + as +
		": missing method " + e.missingMethod
}
func init() {
	jsPkg := js.Global.Get("$packages").Get("github.com/gopherjs/gopherjs/js")
	js.Global.Set("$jsObjectPtr", jsPkg.Get("Object").Get("ptr"))
	js.Global.Set("$jsErrorPtr", jsPkg.Get("Error").Get("ptr"))
	js.Global.Set("$throwRuntimeError", js.InternalObject(throw))
	buildVersion = js.Global.Get("$goVersion").String()
	var e error
	e = &TypeAssertionError{}
	_ = e
}
func GOROOT() string {
	process := js.Global.Get("process")
	if process == js.Undefined {
		return "/"
	}
	if v := process.Get("env").Get("GOPHERJS_GOROOT"); v != js.Undefined && v.String() != "" {
		return v.String()
	} else if v := process.Get("env").Get("GOROOT"); v != js.Undefined && v.String() != "" {
		return v.String()
	}
	return "/usr/local/go"
}
func Breakpoint() { js.Debugger() }
var (
	knownPositions   = map[string]uintptr{}
	positionCounters = []*Func{}
)
func registerPosition(funcName string, file string, line int) uintptr {
	key := file + ":" + itoa(line)
	if pc, found := knownPositions[key]; found {
		return pc
	}
	f := &Func{
		name: funcName,
		file: file,
		line: line,
	}
	pc := uintptr(len(positionCounters))
	positionCounters = append(positionCounters, f)
	knownPositions[key] = pc
	return pc
}
func itoa(i int) string {
	return js.Global.Get("String").New(i).String()
}
type basicFrame struct {
	FuncName string
	File     string
	Line     int
}
func callstack(skip, limit int) []basicFrame {
	skip = skip + 1   + 1  
	lines := js.Global.Get("Error").New().Get("stack").Call("split", "\n").Call("slice", skip)
	frames := []basicFrame{}
	l := lines.Get("length").Int()
	for i := 0; i < l && i < limit; i++ {
		info := lines.Index(i)
		pos := info.Call("substring", info.Call("indexOf", "(").Int()+1, info.Call("indexOf", ")").Int())
		parts := pos.Call("split", ":")
		frames = append(frames, basicFrame{
			File:     parts.Index(0).String(),
			Line:     parts.Index(1).Int(),
			FuncName: info.Call("substring", info.Call("indexOf", "at ").Int()+3, info.Call("indexOf", " (").Int()).String(),
		})
	}
	return frames
}
func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
	skip = skip + 1  
	frames := callstack(skip, 1)
	if len(frames) != 1 {
		return 0, "", 0, false
	}
	pc = registerPosition(frames[0].FuncName, frames[0].File, frames[0].Line)
	return pc, frames[0].File, frames[0].Line, true
}
func Callers(skip int, pc []uintptr) int {
	frames := callstack(skip, len(pc))
	for i, frame := range frames {
		pc[i] = registerPosition(frame.FuncName, frame.File, frame.Line)
	}
	return len(frames)
}
func CallersFrames(callers []uintptr) *Frames {
	result := Frames{}
	for _, pc := range callers {
		fun := FuncForPC(pc)
		result.frames = append(result.frames, Frame{
			PC:       pc,
			Func:     fun,
			Function: fun.name,
			File:     fun.file,
			Line:     fun.line,
			Entry:    fun.Entry(),
		})
	}
	return &result
}
type Frames struct {
	frames  []Frame
	current int
}
func (ci *Frames) Next() (frame Frame, more bool) {
	if ci.current >= len(ci.frames) {
		return Frame{}, false
	}
	f := ci.frames[ci.current]
	ci.current++
	return f, ci.current < len(ci.frames)
}
type Frame struct {
	PC       uintptr
	Func     *Func
	Function string
	File     string
	Line     int
	Entry    uintptr
}
func GC() {}
func Goexit() {
	js.Global.Get("$curGoroutine").Set("exit", true)
	js.Global.Call("$throw", nil)
}
func GOMAXPROCS(int) int { return 1 }
func Gosched() {
	c := make(chan struct{})
	js.Global.Call("$setTimeout", js.InternalObject(func() { close(c) }), 0)
	<-c
}
func NumCPU() int { return 1 }
func NumGoroutine() int {
	return js.Global.Get("$totalGoroutines").Int()
}
type MemStats struct {
	Alloc      uint64  
	TotalAlloc uint64  
	Sys        uint64  
	Lookups    uint64  
	Mallocs    uint64  
	Frees      uint64  
	HeapAlloc    uint64  
	HeapSys      uint64  
	HeapIdle     uint64  
	HeapInuse    uint64  
	HeapReleased uint64  
	HeapObjects  uint64  
	StackInuse  uint64  
	StackSys    uint64
	MSpanInuse  uint64  
	MSpanSys    uint64
	MCacheInuse uint64  
	MCacheSys   uint64
	BuckHashSys uint64  
	GCSys       uint64  
	OtherSys    uint64  
	NextGC        uint64  
	LastGC        uint64  
	PauseTotalNs  uint64
	PauseNs       [256]uint64  
	PauseEnd      [256]uint64  
	NumGC         uint32
	GCCPUFraction float64  
	EnableGC      bool
	DebugGC       bool
	BySize [61]struct {
		Size    uint32
		Mallocs uint64
		Frees   uint64
	}
}
func ReadMemStats(m *MemStats) {
}
func SetFinalizer(x, f interface{}) {
}
type Func struct {
	name string
	file string
	line int
	opaque struct{}  
}
func (_ *Func) Entry() uintptr { return 0 }
func (f *Func) FileLine(pc uintptr) (file string, line int) {
	if f == nil {
		return "", 0
	}
	return f.file, f.line
}
func (f *Func) Name() string {
	if f == nil || f.name == "" {
		return "<unknown>"
	}
	return f.name
}
func FuncForPC(pc uintptr) *Func {
	ipc := int(pc)
	if ipc >= len(positionCounters) {
		panic("GopherJS: pc=" + itoa(ipc) + " is out of range of known position counters")
	}
	return positionCounters[ipc]
}
var MemProfileRate int = 512 * 1024
func SetBlockProfileRate(rate int) {
}
func SetMutexProfileFraction(rate int) int {
	return 0
}
func Stack(buf []byte, all bool) int {
	s := js.Global.Get("Error").New().Get("stack")
	if s == js.Undefined {
		return 0
	}
	return copy(buf, s.Call("substr", s.Call("indexOf", "\n").Int()+1).String())
}
func LockOSThread() {}
func UnlockOSThread() {}
var buildVersion string  
func Version() string {
	return buildVersion
}
func StartTrace() error { return nil }
func StopTrace()        {}
func ReadTrace() []byte