/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.3
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

// source: ./../using_inherit.i

package using_inherit

import "unsafe"
import _ "runtime/cgo"

var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr)



type _ unsafe.Pointer



type _swig_fnptr *byte
type _swig_memberptr *byte

type SwigcptrFoo uintptr

func (p SwigcptrFoo) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrFoo) SwigIsFoo() {
}

var _wrap_Foo_test__SWIG_0 unsafe.Pointer

func _swig_wrap_Foo_test__SWIG_0(base SwigcptrFoo, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Foo_test__SWIG_0, _swig_p)
	return
}

func (arg1 SwigcptrFoo) Test__SWIG_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Foo_test__SWIG_0(arg1, arg2)
}

var _wrap_Foo_test__SWIG_1 unsafe.Pointer

func _swig_wrap_Foo_test__SWIG_1(base SwigcptrFoo, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Foo_test__SWIG_1, _swig_p)
	return
}

func (arg1 SwigcptrFoo) Test__SWIG_1(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Foo_test__SWIG_1(arg1, arg2)
}

func (p SwigcptrFoo) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_1(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Foo unsafe.Pointer

func _swig_wrap_new_Foo() (base SwigcptrFoo) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Foo, _swig_p)
	return
}

func NewFoo() (_swig_ret Foo) {
	return _swig_wrap_new_Foo()
}

var _wrap_delete_Foo unsafe.Pointer

func _swig_wrap_delete_Foo(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Foo, _swig_p)
	return
}

func DeleteFoo(arg1 Foo) {
	_swig_wrap_delete_Foo(arg1.Swigcptr())
}

type Foo interface {
	Swigcptr() uintptr
	SwigIsFoo()
	Test(a ...interface{}) interface{}
}

type SwigcptrBar uintptr

func (p SwigcptrBar) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrBar) SwigIsBar() {
}

var _wrap_Bar_test_SWIG_0_0 unsafe.Pointer

func _swig_wrap_Bar_test_SWIG_0_0(base SwigcptrBar, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar_test_SWIG_0_0, _swig_p)
	return
}

func (arg1 SwigcptrBar) Test_SWIG_0_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Bar_test_SWIG_0_0(arg1, arg2)
}

var _wrap_Bar_test_SWIG_0_1 unsafe.Pointer

func _swig_wrap_Bar_test_SWIG_0_1(base SwigcptrBar, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar_test_SWIG_0_1, _swig_p)
	return
}

func (arg1 SwigcptrBar) Test_SWIG_0_1(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Bar_test_SWIG_0_1(arg1, arg2)
}

func (p SwigcptrBar) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test_SWIG_0_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test_SWIG_0_1(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Bar unsafe.Pointer

func _swig_wrap_new_Bar() (base SwigcptrBar) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Bar, _swig_p)
	return
}

func NewBar() (_swig_ret Bar) {
	return _swig_wrap_new_Bar()
}

var _wrap_delete_Bar unsafe.Pointer

func _swig_wrap_delete_Bar(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Bar, _swig_p)
	return
}

func DeleteBar(arg1 Bar) {
	_swig_wrap_delete_Bar(arg1.Swigcptr())
}

func (p SwigcptrBar) SwigIsFoo() {
}

func (p SwigcptrBar) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Bar interface {
	Swigcptr() uintptr
	SwigIsBar()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}

type SwigcptrBar2 uintptr

func (p SwigcptrBar2) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrBar2) SwigIsBar2() {
}

var _wrap_Bar2_test__SWIG_0 unsafe.Pointer

func _swig_wrap_Bar2_test__SWIG_0(base SwigcptrBar2, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar2_test__SWIG_0, _swig_p)
	return
}

func (arg1 SwigcptrBar2) Test__SWIG_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Bar2_test__SWIG_0(arg1, arg2)
}

var _wrap_Bar2_test__SWIG_1 unsafe.Pointer

func _swig_wrap_Bar2_test__SWIG_1(base SwigcptrBar2, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar2_test__SWIG_1, _swig_p)
	return
}

func (arg1 SwigcptrBar2) Test__SWIG_1(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Bar2_test__SWIG_1(arg1, arg2)
}

func (p SwigcptrBar2) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_1(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Bar2 unsafe.Pointer

func _swig_wrap_new_Bar2() (base SwigcptrBar2) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Bar2, _swig_p)
	return
}

func NewBar2() (_swig_ret Bar2) {
	return _swig_wrap_new_Bar2()
}

var _wrap_delete_Bar2 unsafe.Pointer

func _swig_wrap_delete_Bar2(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Bar2, _swig_p)
	return
}

func DeleteBar2(arg1 Bar2) {
	_swig_wrap_delete_Bar2(arg1.Swigcptr())
}

func (p SwigcptrBar2) SwigIsFoo() {
}

func (p SwigcptrBar2) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Bar2 interface {
	Swigcptr() uintptr
	SwigIsBar2()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}

type SwigcptrBar3 uintptr

func (p SwigcptrBar3) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrBar3) SwigIsBar3() {
}

var _wrap_Bar3_test__SWIG_0 unsafe.Pointer

func _swig_wrap_Bar3_test__SWIG_0(base SwigcptrBar3, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar3_test__SWIG_0, _swig_p)
	return
}

func (arg1 SwigcptrBar3) Test__SWIG_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Bar3_test__SWIG_0(arg1, arg2)
}

var _wrap_Bar3_test__SWIG_1 unsafe.Pointer

func _swig_wrap_Bar3_test__SWIG_1(base SwigcptrBar3, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar3_test__SWIG_1, _swig_p)
	return
}

func (arg1 SwigcptrBar3) Test__SWIG_1(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Bar3_test__SWIG_1(arg1, arg2)
}

func (p SwigcptrBar3) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_1(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Bar3 unsafe.Pointer

func _swig_wrap_new_Bar3() (base SwigcptrBar3) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Bar3, _swig_p)
	return
}

func NewBar3() (_swig_ret Bar3) {
	return _swig_wrap_new_Bar3()
}

var _wrap_delete_Bar3 unsafe.Pointer

func _swig_wrap_delete_Bar3(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Bar3, _swig_p)
	return
}

func DeleteBar3(arg1 Bar3) {
	_swig_wrap_delete_Bar3(arg1.Swigcptr())
}

func (p SwigcptrBar3) SwigIsFoo() {
}

func (p SwigcptrBar3) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Bar3 interface {
	Swigcptr() uintptr
	SwigIsBar3()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}

type SwigcptrBar4 uintptr

func (p SwigcptrBar4) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrBar4) SwigIsBar4() {
}

var _wrap_Bar4_test__SWIG_0 unsafe.Pointer

func _swig_wrap_Bar4_test__SWIG_0(base SwigcptrBar4, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar4_test__SWIG_0, _swig_p)
	return
}

func (arg1 SwigcptrBar4) Test__SWIG_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Bar4_test__SWIG_0(arg1, arg2)
}

var _wrap_Bar4_test__SWIG_2 unsafe.Pointer

func _swig_wrap_Bar4_test__SWIG_2(base SwigcptrBar4, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Bar4_test__SWIG_2, _swig_p)
	return
}

func (arg1 SwigcptrBar4) Test__SWIG_2(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Bar4_test__SWIG_2(arg1, arg2)
}

func (p SwigcptrBar4) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_2(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Bar4 unsafe.Pointer

func _swig_wrap_new_Bar4() (base SwigcptrBar4) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Bar4, _swig_p)
	return
}

func NewBar4() (_swig_ret Bar4) {
	return _swig_wrap_new_Bar4()
}

var _wrap_delete_Bar4 unsafe.Pointer

func _swig_wrap_delete_Bar4(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Bar4, _swig_p)
	return
}

func DeleteBar4(arg1 Bar4) {
	_swig_wrap_delete_Bar4(arg1.Swigcptr())
}

func (p SwigcptrBar4) SwigIsFoo() {
}

func (p SwigcptrBar4) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Bar4 interface {
	Swigcptr() uintptr
	SwigIsBar4()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}

type SwigcptrFred1 uintptr

func (p SwigcptrFred1) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrFred1) SwigIsFred1() {
}

var _wrap_Fred1_test__SWIG_0_0 unsafe.Pointer

func _swig_wrap_Fred1_test__SWIG_0_0(base SwigcptrFred1, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Fred1_test__SWIG_0_0, _swig_p)
	return
}

func (arg1 SwigcptrFred1) Test__SWIG_0_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Fred1_test__SWIG_0_0(arg1, arg2)
}

var _wrap_Fred1_test__SWIG_1 unsafe.Pointer

func _swig_wrap_Fred1_test__SWIG_1(base SwigcptrFred1, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Fred1_test__SWIG_1, _swig_p)
	return
}

func (arg1 SwigcptrFred1) Test__SWIG_1(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Fred1_test__SWIG_1(arg1, arg2)
}

func (p SwigcptrFred1) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_0_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_1(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Fred1 unsafe.Pointer

func _swig_wrap_new_Fred1() (base SwigcptrFred1) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Fred1, _swig_p)
	return
}

func NewFred1() (_swig_ret Fred1) {
	return _swig_wrap_new_Fred1()
}

var _wrap_delete_Fred1 unsafe.Pointer

func _swig_wrap_delete_Fred1(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Fred1, _swig_p)
	return
}

func DeleteFred1(arg1 Fred1) {
	_swig_wrap_delete_Fred1(arg1.Swigcptr())
}

func (p SwigcptrFred1) SwigIsFoo() {
}

func (p SwigcptrFred1) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Fred1 interface {
	Swigcptr() uintptr
	SwigIsFred1()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}

type SwigcptrFred2 uintptr

func (p SwigcptrFred2) Swigcptr() uintptr {
	return (uintptr)(p)
}

func (p SwigcptrFred2) SwigIsFred2() {
}

var _wrap_Fred2_test__SWIG_0 unsafe.Pointer

func _swig_wrap_Fred2_test__SWIG_0(base SwigcptrFred2, _ float64) (_ float64) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Fred2_test__SWIG_0, _swig_p)
	return
}

func (arg1 SwigcptrFred2) Test__SWIG_0(arg2 float64) (_swig_ret float64) {
	return _swig_wrap_Fred2_test__SWIG_0(arg1, arg2)
}

var _wrap_Fred2_test__SWIG_1_0 unsafe.Pointer

func _swig_wrap_Fred2_test__SWIG_1_0(base SwigcptrFred2, _ int) (_ int) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_Fred2_test__SWIG_1_0, _swig_p)
	return
}

func (arg1 SwigcptrFred2) Test__SWIG_1_0(arg2 int) (_swig_ret int) {
	return _swig_wrap_Fred2_test__SWIG_1_0(arg1, arg2)
}

func (p SwigcptrFred2) Test(a ...interface{}) interface{} {
	argc := len(a)
	if argc == 1 {
		if _, ok := a[0].(int); !ok {
			goto check_1
		}
		return p.Test__SWIG_1_0(a[0].(int))
	}
check_1:
	if argc == 1 {
		return p.Test__SWIG_0(a[0].(float64))
	}
	panic("No match for overloaded function call")
}

var _wrap_new_Fred2 unsafe.Pointer

func _swig_wrap_new_Fred2() (base SwigcptrFred2) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_new_Fred2, _swig_p)
	return
}

func NewFred2() (_swig_ret Fred2) {
	return _swig_wrap_new_Fred2()
}

var _wrap_delete_Fred2 unsafe.Pointer

func _swig_wrap_delete_Fred2(base uintptr) {
	_swig_p := uintptr(unsafe.Pointer(&base))
	_cgo_runtime_cgocall(_wrap_delete_Fred2, _swig_p)
	return
}

func DeleteFred2(arg1 Fred2) {
	_swig_wrap_delete_Fred2(arg1.Swigcptr())
}

func (p SwigcptrFred2) SwigIsFoo() {
}

func (p SwigcptrFred2) SwigGetFoo() Foo {
	return SwigcptrFoo(p.Swigcptr())
}

type Fred2 interface {
	Swigcptr() uintptr
	SwigIsFred2()
	Test(a ...interface{}) interface{}
	SwigIsFoo()
	SwigGetFoo() Foo
}


type SwigcptrVoid uintptr
type Void interface {
	Swigcptr() uintptr;
}
func (p SwigcptrVoid) Swigcptr() uintptr {
	return uintptr(p)
}