func LogmathLogToLn(lmath *Logmath, logbP int32) float64 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	clogbP, _ := (C.int)(logbP), cgoAllocsUnknown
	__ret := C.logmath_log_to_ln(clmath, clogbP)
	__v := (float64)(__ret)
	return __v
}
LogmathLogToLn function as declared in sphinxbase/logmath.h:218
package pocketsphinx
import "C"
import "unsafe"
func DefaultSearchArgs(arg0 []CommandLn) {
	carg0, _ := (*C.cmd_ln_t)(unsafe.Pointer((*sliceHeader)(unsafe.Pointer(&arg0)).Data)), cgoAllocsUnknown
	C.ps_default_search_args(carg0)
}
func Init(config *CommandLn) *Decoder {
	cconfig, _ := (*C.cmd_ln_t)(unsafe.Pointer(config)), cgoAllocsUnknown
	__ret := C.ps_init(cconfig)
	__v := *(**Decoder)(unsafe.Pointer(&__ret))
	return __v
}
func Reinit(ps *Decoder, config *CommandLn) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cconfig, _ := (*C.cmd_ln_t)(unsafe.Pointer(config)), cgoAllocsUnknown
	__ret := C.ps_reinit(cps, cconfig)
	__v := (int32)(__ret)
	return __v
}
func Args0() []Arg {
	__ret := C.ps_args()
	var __v []Arg
	packSArg(__v, __ret)
	return __v
}
func Retain(ps *Decoder) *Decoder {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_retain(cps)
	__v := *(**Decoder)(unsafe.Pointer(&__ret))
	return __v
}
func Free(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_free(cps)
	__v := (int32)(__ret)
	return __v
}
func GetConfig(ps *Decoder) *CommandLn {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_config(cps)
	__v := *(**CommandLn)(unsafe.Pointer(&__ret))
	return __v
}
func GetLogmath(ps *Decoder) *Logmath {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_logmath(cps)
	__v := *(**Logmath)(unsafe.Pointer(&__ret))
	return __v
}
func GetFe(ps *Decoder) *Fe {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_fe(cps)
	__v := *(**Fe)(unsafe.Pointer(&__ret))
	return __v
}
func GetFeat(ps *Decoder) *Feat {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_feat(cps)
	__v := *(**Feat)(unsafe.Pointer(&__ret))
	return __v
}
func UpdateMllr(ps *Decoder, mllr *Mllr) *Mllr {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cmllr, _ := (*C.ps_mllr_t)(unsafe.Pointer(mllr)), cgoAllocsUnknown
	__ret := C.ps_update_mllr(cps, cmllr)
	__v := *(**Mllr)(unsafe.Pointer(&__ret))
	return __v
}
func LoadDict(ps *Decoder, dictfile string, fdictfile string, format string) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cdictfile, _ := unpackPCharString(dictfile)
	cfdictfile, _ := unpackPCharString(fdictfile)
	cformat, _ := unpackPCharString(format)
	__ret := C.ps_load_dict(cps, cdictfile, cfdictfile, cformat)
	__v := (int32)(__ret)
	return __v
}
func SaveDict(ps *Decoder, dictfile string, format string) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cdictfile, _ := unpackPCharString(dictfile)
	cformat, _ := unpackPCharString(format)
	__ret := C.ps_save_dict(cps, cdictfile, cformat)
	__v := (int32)(__ret)
	return __v
}
func AddWord(ps *Decoder, word string, phones string, update int32) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cword, _ := unpackPCharString(word)
	cphones, _ := unpackPCharString(phones)
	cupdate, _ := (C.int)(update), cgoAllocsUnknown
	__ret := C.ps_add_word(cps, cword, cphones, cupdate)
	__v := (int32)(__ret)
	return __v
}
func LookupWord(ps *Decoder, word string) []byte {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cword, _ := unpackPCharString(word)
	__ret := C.ps_lookup_word(cps, cword)
	__v := (*(*[0x1fffffff]byte)(unsafe.Pointer(__ret)))[:0]
	return __v
}
func DecodeRaw(ps *Decoder, rawfh *File, maxsamps int) int {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	crawfh, _ := (*C.FILE)(unsafe.Pointer(rawfh)), cgoAllocsUnknown
	cmaxsamps, _ := (C.long)(maxsamps), cgoAllocsUnknown
	__ret := C.ps_decode_raw(cps, crawfh, cmaxsamps)
	__v := (int)(__ret)
	return __v
}
func DecodeSenscr(ps *Decoder, senfh *File) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	csenfh, _ := (*C.FILE)(unsafe.Pointer(senfh)), cgoAllocsUnknown
	__ret := C.ps_decode_senscr(cps, csenfh)
	__v := (int32)(__ret)
	return __v
}
func StartStream(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_start_stream(cps)
	__v := (int32)(__ret)
	return __v
}
func StartUtt(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_start_utt(cps)
	__v := (int32)(__ret)
	return __v
}
func ProcessRaw(ps *Decoder, data []int16, nSamples uint, noSearch int32, fullUtt int32) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cdata, _ := (*C.int16)(unsafe.Pointer((*sliceHeader)(unsafe.Pointer(&data)).Data)), cgoAllocsUnknown
	cnSamples, _ := (C.size_t)(nSamples), cgoAllocsUnknown
	cnoSearch, _ := (C.int)(noSearch), cgoAllocsUnknown
	cfullUtt, _ := (C.int)(fullUtt), cgoAllocsUnknown
	__ret := C.ps_process_raw(cps, cdata, cnSamples, cnoSearch, cfullUtt)
	__v := (int32)(__ret)
	return __v
}
func ProcessCep(ps *Decoder, data [][]float32, nFrames int32, noSearch int32, fullUtt int32) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cdata, _ := unpackArgSSFloat32(data)
	cnFrames, _ := (C.int)(nFrames), cgoAllocsUnknown
	cnoSearch, _ := (C.int)(noSearch), cgoAllocsUnknown
	cfullUtt, _ := (C.int)(fullUtt), cgoAllocsUnknown
	__ret := C.ps_process_cep(cps, cdata, cnFrames, cnoSearch, cfullUtt)
	packSSFloat32(data, cdata)
	__v := (int32)(__ret)
	return __v
}
func GetNFrames(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_n_frames(cps)
	__v := (int32)(__ret)
	return __v
}
func EndUtt(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_end_utt(cps)
	__v := (int32)(__ret)
	return __v
}
func GetHyp(ps *Decoder, outBestScore *int32) string {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	coutBestScore, _ := (*C.int32)(unsafe.Pointer(outBestScore)), cgoAllocsUnknown
	__ret := C.ps_get_hyp(cps, coutBestScore)
	__v := packPCharString(__ret)
	return __v
}
func GetProb(ps *Decoder) int32 {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_prob(cps)
	__v := (int32)(__ret)
	return __v
}
func GetLattice(ps *Decoder) *Lattice {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_lattice(cps)
	__v := *(**Lattice)(unsafe.Pointer(&__ret))
	return __v
}
func SegIter(ps *Decoder) *Seg {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_seg_iter(cps)
	__v := *(**Seg)(unsafe.Pointer(&__ret))
	return __v
}
func SegNext(seg *Seg) *Seg {
	cseg, _ := (*C.ps_seg_t)(unsafe.Pointer(seg)), cgoAllocsUnknown
	__ret := C.ps_seg_next(cseg)
	__v := *(**Seg)(unsafe.Pointer(&__ret))
	return __v
}
func SegWord(seg *Seg) string {
	cseg, _ := (*C.ps_seg_t)(unsafe.Pointer(seg)), cgoAllocsUnknown
	__ret := C.ps_seg_word(cseg)
	__v := packPCharString(__ret)
	return __v
}
func SegFrames(seg *Seg, outSf *int32, outEf *int32) {
	cseg, _ := (*C.ps_seg_t)(unsafe.Pointer(seg)), cgoAllocsUnknown
	coutSf, _ := (*C.int)(unsafe.Pointer(outSf)), cgoAllocsUnknown
	coutEf, _ := (*C.int)(unsafe.Pointer(outEf)), cgoAllocsUnknown
	C.ps_seg_frames(cseg, coutSf, coutEf)
}
func SegProb(seg *Seg, outAscr *int32, outLscr *int32, outLback *int32) int32 {
	cseg, _ := (*C.ps_seg_t)(unsafe.Pointer(seg)), cgoAllocsUnknown
	coutAscr, _ := (*C.int32)(unsafe.Pointer(outAscr)), cgoAllocsUnknown
	coutLscr, _ := (*C.int32)(unsafe.Pointer(outLscr)), cgoAllocsUnknown
	coutLback, _ := (*C.int32)(unsafe.Pointer(outLback)), cgoAllocsUnknown
	__ret := C.ps_seg_prob(cseg, coutAscr, coutLscr, coutLback)
	__v := (int32)(__ret)
	return __v
}
func SegFree(seg *Seg) {
	cseg, _ := (*C.ps_seg_t)(unsafe.Pointer(seg)), cgoAllocsUnknown
	C.ps_seg_free(cseg)
}
func GetNbest(ps *Decoder) *Nbest {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_nbest(cps)
	__v := *(**Nbest)(unsafe.Pointer(&__ret))
	return __v
}
func NbestNext(nbest *Nbest) *Nbest {
	cnbest, _ := (*C.ps_nbest_t)(unsafe.Pointer(nbest)), cgoAllocsUnknown
	__ret := C.ps_nbest_next(cnbest)
	__v := *(**Nbest)(unsafe.Pointer(&__ret))
	return __v
}
func NbestHyp(nbest *Nbest, outScore *int32) string {
	cnbest, _ := (*C.ps_nbest_t)(unsafe.Pointer(nbest)), cgoAllocsUnknown
	coutScore, _ := (*C.int32)(unsafe.Pointer(outScore)), cgoAllocsUnknown
	__ret := C.ps_nbest_hyp(cnbest, coutScore)
	__v := packPCharString(__ret)
	return __v
}
func NbestSeg(nbest *Nbest) *Seg {
	cnbest, _ := (*C.ps_nbest_t)(unsafe.Pointer(nbest)), cgoAllocsUnknown
	__ret := C.ps_nbest_seg(cnbest)
	__v := *(**Seg)(unsafe.Pointer(&__ret))
	return __v
}
func NbestFree(nbest *Nbest) {
	cnbest, _ := (*C.ps_nbest_t)(unsafe.Pointer(nbest)), cgoAllocsUnknown
	C.ps_nbest_free(cnbest)
}
func GetUttTime(ps *Decoder, outNspeech *float64, outNcpu *float64, outNwall *float64) {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	coutNspeech, _ := (*C.double)(unsafe.Pointer(outNspeech)), cgoAllocsUnknown
	coutNcpu, _ := (*C.double)(unsafe.Pointer(outNcpu)), cgoAllocsUnknown
	coutNwall, _ := (*C.double)(unsafe.Pointer(outNwall)), cgoAllocsUnknown
	C.ps_get_utt_time(cps, coutNspeech, coutNcpu, coutNwall)
}
func GetAllTime(ps *Decoder, outNspeech *float64, outNcpu *float64, outNwall *float64) {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	coutNspeech, _ := (*C.double)(unsafe.Pointer(outNspeech)), cgoAllocsUnknown
	coutNcpu, _ := (*C.double)(unsafe.Pointer(outNcpu)), cgoAllocsUnknown
	coutNwall, _ := (*C.double)(unsafe.Pointer(outNwall)), cgoAllocsUnknown
	C.ps_get_all_time(cps, coutNspeech, coutNcpu, coutNwall)
}
func GetInSpeech(ps *Decoder) byte {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	__ret := C.ps_get_in_speech(cps)
	__v := (byte)(__ret)
	return __v
}
func SetRawdataSize(ps *Decoder, size int32) {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	csize, _ := (C.int32)(size), cgoAllocsUnknown
	C.ps_set_rawdata_size(cps, csize)
}
func GetRawdata(ps *Decoder, buffer [][]int16, size *int32) {
	cps, _ := (*C.ps_decoder_t)(unsafe.Pointer(ps)), cgoAllocsUnknown
	cbuffer, _ := unpackArgSSInt16(buffer)
	csize, _ := (*C.int32)(unsafe.Pointer(size)), cgoAllocsUnknown
	C.ps_get_rawdata(cps, cbuffer, csize)
	packSSInt16(buffer, cbuffer)
}
func CommandLnRetain(cmdln *CommandLn) *CommandLn {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	__ret := C.cmd_ln_retain(ccmdln)
	__v := *(**CommandLn)(unsafe.Pointer(&__ret))
	return __v
}
func CommandLnFreeR(cmdln *CommandLn) int32 {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	__ret := C.cmd_ln_free_r(ccmdln)
	__v := (int32)(__ret)
	return __v
}
func CommandLnParseR(inoutCmdln *CommandLn, defn []Arg, argc int32, argv [][]byte, strict int32) *CommandLn {
	cinoutCmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(inoutCmdln)), cgoAllocsUnknown
	cdefn, _ := unpackArgSArg(defn)
	cargc, _ := (C.int32)(argc), cgoAllocsUnknown
	cargv, _ := unpackArgSSByte(argv)
	cstrict, _ := (C.int32)(strict), cgoAllocsUnknown
	__ret := C.cmd_ln_parse_r(cinoutCmdln, cdefn, cargc, cargv, cstrict)
	packSSByte(argv, cargv)
	packSArg(defn, cdefn)
	__v := *(**CommandLn)(unsafe.Pointer(&__ret))
	return __v
}
func CommandLnParseFileR(inoutCmdln *CommandLn, defn []Arg, filename string, strict int32) *CommandLn {
	cinoutCmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(inoutCmdln)), cgoAllocsUnknown
	cdefn, _ := unpackArgSArg(defn)
	cfilename, _ := unpackPCharString(filename)
	cstrict, _ := (C.int32)(strict), cgoAllocsUnknown
	__ret := C.cmd_ln_parse_file_r(cinoutCmdln, cdefn, cfilename, cstrict)
	packSArg(defn, cdefn)
	__v := *(**CommandLn)(unsafe.Pointer(&__ret))
	return __v
}
func CommandLnAccessR(cmdln *CommandLn, name string) *Anytype {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_access_r(ccmdln, cname)
	__v := *(**Anytype)(unsafe.Pointer(&__ret))
	return __v
}
func CommandLnStrR(cmdln *CommandLn, name string) string {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_str_r(ccmdln, cname)
	__v := packPCharString(__ret)
	return __v
}
func CommandLnStrListR(cmdln *CommandLn, name string) []string {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_str_list_r(ccmdln, cname)
	var __v []string
	packSString(__v, __ret)
	return __v
}
func CommandLnIntR(cmdln *CommandLn, name string) int {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_int_r(ccmdln, cname)
	__v := (int)(__ret)
	return __v
}
func CommandLnFloatR(cmdln *CommandLn, name string) float64 {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_float_r(ccmdln, cname)
	__v := (float64)(__ret)
	return __v
}
func CommandLnSetStrR(cmdln *CommandLn, name string, str string) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	cstr, _ := unpackPCharString(str)
	C.cmd_ln_set_str_r(ccmdln, cname, cstr)
}
func CommandLnSetStrExtraR(cmdln *CommandLn, name string, str string) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	cstr, _ := unpackPCharString(str)
	C.cmd_ln_set_str_extra_r(ccmdln, cname, cstr)
}
func CommandLnSetIntR(cmdln *CommandLn, name string, iv int) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	civ, _ := (C.long)(iv), cgoAllocsUnknown
	C.cmd_ln_set_int_r(ccmdln, cname, civ)
}
func CommandLnSetFloatR(cmdln *CommandLn, name string, fv float64) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	cfv, _ := (C.double)(fv), cgoAllocsUnknown
	C.cmd_ln_set_float_r(ccmdln, cname, cfv)
}
func CommandLnExistsR(cmdln *CommandLn, name string) int32 {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cname, _ := unpackPCharString(name)
	__ret := C.cmd_ln_exists_r(ccmdln, cname)
	__v := (int32)(__ret)
	return __v
}
func CommandLnPrintHelpR(cmdln *CommandLn, fp *File, defn *Arg) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cfp, _ := (*C.FILE)(unsafe.Pointer(fp)), cgoAllocsUnknown
	cdefn, _ := defn.PassRef()
	C.cmd_ln_print_help_r(ccmdln, cfp, cdefn)
}
func CommandLnPrintValuesR(cmdln *CommandLn, fp *File, defn *Arg) {
	ccmdln, _ := (*C.cmd_ln_t)(unsafe.Pointer(cmdln)), cgoAllocsUnknown
	cfp, _ := (*C.FILE)(unsafe.Pointer(fp)), cgoAllocsUnknown
	cdefn, _ := defn.PassRef()
	C.cmd_ln_print_values_r(ccmdln, cfp, cdefn)
}
func CommandLnParse(defn *Arg, argc int32, argv [][]byte, strict int32) int32 {
	cdefn, _ := defn.PassRef()
	cargc, _ := (C.int32)(argc), cgoAllocsUnknown
	cargv, _ := unpackArgSSByte(argv)
	cstrict, _ := (C.int32)(strict), cgoAllocsUnknown
	__ret := C.cmd_ln_parse(cdefn, cargc, cargv, cstrict)
	packSSByte(argv, cargv)
	__v := (int32)(__ret)
	return __v
}
func CommandLnParseFile(defn *Arg, filename string, strict int32) int32 {
	cdefn, _ := defn.PassRef()
	cfilename, _ := unpackPCharString(filename)
	cstrict, _ := (C.int32)(strict), cgoAllocsUnknown
	__ret := C.cmd_ln_parse_file(cdefn, cfilename, cstrict)
	__v := (int32)(__ret)
	return __v
}
func CommandLnApplEnter(argc int32, argv [][]byte, defaultArgfn string, defn *Arg) {
	cargc, _ := (C.int)(argc), cgoAllocsUnknown
	cargv, _ := unpackArgSSByte(argv)
	cdefaultArgfn, _ := unpackPCharString(defaultArgfn)
	cdefn, _ := defn.PassRef()
	C.cmd_ln_appl_enter(cargc, cargv, cdefaultArgfn, cdefn)
	packSSByte(argv, cargv)
}
func CommandLnApplExit() {
	C.cmd_ln_appl_exit()
}
func CommandLnGet() *CommandLn {
	__ret := C.cmd_ln_get()
	__v := *(**CommandLn)(unsafe.Pointer(&__ret))
	return __v
}
func CommandLnFree() {
	C.cmd_ln_free()
}
func LogmathInit(base float64, shift int32, useTable int32) *Logmath {
	cbase, _ := (C.float64)(base), cgoAllocsUnknown
	cshift, _ := (C.int)(shift), cgoAllocsUnknown
	cuseTable, _ := (C.int)(useTable), cgoAllocsUnknown
	__ret := C.logmath_init(cbase, cshift, cuseTable)
	__v := *(**Logmath)(unsafe.Pointer(&__ret))
	return __v
}
func LogmathRead(filename string) *Logmath {
	cfilename, _ := unpackPCharString(filename)
	__ret := C.logmath_read(cfilename)
	__v := *(**Logmath)(unsafe.Pointer(&__ret))
	return __v
}
func LogmathWrite(lmath *Logmath, filename string) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	cfilename, _ := unpackPCharString(filename)
	__ret := C.logmath_write(clmath, cfilename)
	__v := (int32)(__ret)
	return __v
}
func LogmathGetTableShape(lmath *Logmath, outSize *uint32, outWidth *uint32, outShift *uint32) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	coutSize, _ := (*C.uint32)(unsafe.Pointer(outSize)), cgoAllocsUnknown
	coutWidth, _ := (*C.uint32)(unsafe.Pointer(outWidth)), cgoAllocsUnknown
	coutShift, _ := (*C.uint32)(unsafe.Pointer(outShift)), cgoAllocsUnknown
	__ret := C.logmath_get_table_shape(clmath, coutSize, coutWidth, coutShift)
	__v := (int32)(__ret)
	return __v
}
func LogmathGetBase(lmath *Logmath) float64 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_get_base(clmath)
	__v := (float64)(__ret)
	return __v
}
func LogmathGetZero(lmath *Logmath) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_get_zero(clmath)
	__v := (int32)(__ret)
	return __v
}
func LogmathGetWidth(lmath *Logmath) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_get_width(clmath)
	__v := (int32)(__ret)
	return __v
}
func LogmathGetShift(lmath *Logmath) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_get_shift(clmath)
	__v := (int32)(__ret)
	return __v
}
func LogmathRetain(lmath *Logmath) *Logmath {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_retain(clmath)
	__v := *(**Logmath)(unsafe.Pointer(&__ret))
	return __v
}
func LogmathFree(lmath *Logmath) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	__ret := C.logmath_free(clmath)
	__v := (int32)(__ret)
	return __v
}
func LogmathAddExact(lmath *Logmath, logbP int32, logbQ int32) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	clogbP, _ := (C.int)(logbP), cgoAllocsUnknown
	clogbQ, _ := (C.int)(logbQ), cgoAllocsUnknown
	__ret := C.logmath_add_exact(clmath, clogbP, clogbQ)
	__v := (int32)(__ret)
	return __v
}
func LogmathAdd(lmath *Logmath, logbP int32, logbQ int32) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	clogbP, _ := (C.int)(logbP), cgoAllocsUnknown
	clogbQ, _ := (C.int)(logbQ), cgoAllocsUnknown
	__ret := C.logmath_add(clmath, clogbP, clogbQ)
	__v := (int32)(__ret)
	return __v
}
func LogmathLog(lmath *Logmath, p float64) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	cp, _ := (C.float64)(p), cgoAllocsUnknown
	__ret := C.logmath_log(clmath, cp)
	__v := (int32)(__ret)
	return __v
}
func LogmathExp(lmath *Logmath, logbP int32) float64 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	clogbP, _ := (C.int)(logbP), cgoAllocsUnknown
	__ret := C.logmath_exp(clmath, clogbP)
	__v := (float64)(__ret)
	return __v
}
func LogmathLnToLog(lmath *Logmath, logP float64) int32 {
	clmath, _ := (*C.logmath_t)(unsafe.Pointer(lmath)), cgoAllocsUnknown
	clogP, _ := (C.float64)(logP), cgoAllocsUnknown
	__ret := C.logmath_ln_to_log(clmath, clogP)
	__v := (int32)(__ret)
	return __v
}