function_ruby_3_3_generated.go

// THE AUTOGENERATED LICENSE. ALL THE RIGHTS ARE RESERVED BY ROBOTS.

// WARNING: This file has automatically been generated
// Code generated by ruby_h_to_go. DO NOT EDIT.

// FIXME: https://pkg.go.dev/ doesn't support custom build tag.
//        Therefore, if no build tag is passed, treat it as the default tag
//go:build ruby_3_3 || !ruby_3_4

package ruby

/*
#include "ruby.h"
*/
import "C"

import (
	"unsafe"
)

// RARRAY_ASET calls `RARRAY_ASET` in C
//
// Original definition is following
//
//	RARRAY_ASET(VALUE ary, long i, VALUE v)
func RARRAY_ASET(ary VALUE, i Long, v VALUE) {
	C.RARRAY_ASET(C.VALUE(ary), C.long(i), C.VALUE(v))
}

// RARRAY_EMBED_LEN calls `RARRAY_EMBED_LEN` in C
//
// Original definition is following
//
//	RARRAY_EMBED_LEN(VALUE ary)
func RARRAY_EMBED_LEN(ary VALUE) Long {
	return Long(C.RARRAY_EMBED_LEN(C.VALUE(ary)))
}

// RARRAY_LENINT calls `RARRAY_LENINT` in C
//
// Original definition is following
//
//	RARRAY_LENINT(VALUE ary)
func RARRAY_LENINT(ary VALUE) int {
	return int(C.RARRAY_LENINT(C.VALUE(ary)))
}

// RARRAY_PTR calls `RARRAY_PTR` in C
//
// Original definition is following
//
//	RARRAY_PTR(VALUE ary)
func RARRAY_PTR(ary VALUE) *VALUE {
	return (*VALUE)(C.RARRAY_PTR(C.VALUE(ary)))
}

// RB_BUILTIN_TYPE calls `RB_BUILTIN_TYPE` in C
//
// Original definition is following
//
//	RB_BUILTIN_TYPE(VALUE obj)
func RB_BUILTIN_TYPE(obj VALUE) RubyValueType {
	return RubyValueType(C.RB_BUILTIN_TYPE(C.VALUE(obj)))
}

// RB_CHR2FIX calls `RB_CHR2FIX` in C
//
// Original definition is following
//
//	RB_CHR2FIX(unsigned char c)
func RB_CHR2FIX(c Uchar) VALUE {
	return VALUE(C.RB_CHR2FIX(C.uchar(c)))
}

// RB_DYNAMIC_SYM_P calls `RB_DYNAMIC_SYM_P` in C
//
// Original definition is following
//
//	RB_DYNAMIC_SYM_P(VALUE obj)
func RB_DYNAMIC_SYM_P(obj VALUE) Bool {
	return Bool(C.RB_DYNAMIC_SYM_P(C.VALUE(obj)))
}

// RB_FIX2INT calls `RB_FIX2INT` in C
//
// Original definition is following
//
//	RB_FIX2INT(VALUE x)
func RB_FIX2INT(x VALUE) int {
	return int(C.RB_FIX2INT(C.VALUE(x)))
}

// RB_FIX2UINT calls `RB_FIX2UINT` in C
//
// Original definition is following
//
//	RB_FIX2UINT(VALUE x)
func RB_FIX2UINT(x VALUE) uint {
	return uint(C.RB_FIX2UINT(C.VALUE(x)))
}

// RB_FIXNUM_P calls `RB_FIXNUM_P` in C
//
// Original definition is following
//
//	RB_FIXNUM_P(VALUE obj)
func RB_FIXNUM_P(obj VALUE) Bool {
	return Bool(C.RB_FIXNUM_P(C.VALUE(obj)))
}

// RB_FLOAT_TYPE_P calls `RB_FLOAT_TYPE_P` in C
//
// Original definition is following
//
//	RB_FLOAT_TYPE_P(VALUE obj)
func RB_FLOAT_TYPE_P(obj VALUE) Bool {
	return Bool(C.RB_FLOAT_TYPE_P(C.VALUE(obj)))
}

// RB_FLONUM_P calls `RB_FLONUM_P` in C
//
// Original definition is following
//
//	RB_FLONUM_P(VALUE obj)
func RB_FLONUM_P(obj VALUE) Bool {
	return Bool(C.RB_FLONUM_P(C.VALUE(obj)))
}

// RB_FL_ABLE calls `RB_FL_ABLE` in C
//
// Original definition is following
//
//	RB_FL_ABLE(VALUE obj)
func RB_FL_ABLE(obj VALUE) Bool {
	return Bool(C.RB_FL_ABLE(C.VALUE(obj)))
}

// RB_FL_ALL calls `RB_FL_ALL` in C
//
// Original definition is following
//
//	RB_FL_ALL(VALUE obj, VALUE flags)
func RB_FL_ALL(obj VALUE, flags VALUE) Bool {
	return Bool(C.RB_FL_ALL(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_ALL_RAW calls `RB_FL_ALL_RAW` in C
//
// Original definition is following
//
//	RB_FL_ALL_RAW(VALUE obj, VALUE flags)
func RB_FL_ALL_RAW(obj VALUE, flags VALUE) Bool {
	return Bool(C.RB_FL_ALL_RAW(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_ANY calls `RB_FL_ANY` in C
//
// Original definition is following
//
//	RB_FL_ANY(VALUE obj, VALUE flags)
func RB_FL_ANY(obj VALUE, flags VALUE) Bool {
	return Bool(C.RB_FL_ANY(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_ANY_RAW calls `RB_FL_ANY_RAW` in C
//
// Original definition is following
//
//	RB_FL_ANY_RAW(VALUE obj, VALUE flags)
func RB_FL_ANY_RAW(obj VALUE, flags VALUE) Bool {
	return Bool(C.RB_FL_ANY_RAW(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_REVERSE calls `RB_FL_REVERSE` in C
//
// Original definition is following
//
//	RB_FL_REVERSE(VALUE obj, VALUE flags)
func RB_FL_REVERSE(obj VALUE, flags VALUE) {
	C.RB_FL_REVERSE(C.VALUE(obj), C.VALUE(flags))
}

// RB_FL_REVERSE_RAW calls `RB_FL_REVERSE_RAW` in C
//
// Original definition is following
//
//	RB_FL_REVERSE_RAW(VALUE obj, VALUE flags)
func RB_FL_REVERSE_RAW(obj VALUE, flags VALUE) {
	C.RB_FL_REVERSE_RAW(C.VALUE(obj), C.VALUE(flags))
}

// RB_FL_SET calls `RB_FL_SET` in C
//
// Original definition is following
//
//	RB_FL_SET(VALUE obj, VALUE flags)
func RB_FL_SET(obj VALUE, flags VALUE) {
	C.RB_FL_SET(C.VALUE(obj), C.VALUE(flags))
}

// RB_FL_SET_RAW calls `RB_FL_SET_RAW` in C
//
// Original definition is following
//
//	RB_FL_SET_RAW(VALUE obj, VALUE flags)
func RB_FL_SET_RAW(obj VALUE, flags VALUE) {
	C.RB_FL_SET_RAW(C.VALUE(obj), C.VALUE(flags))
}

// RB_FL_TEST calls `RB_FL_TEST` in C
//
// Original definition is following
//
//	RB_FL_TEST(VALUE obj, VALUE flags)
func RB_FL_TEST(obj VALUE, flags VALUE) VALUE {
	return VALUE(C.RB_FL_TEST(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_TEST_RAW calls `RB_FL_TEST_RAW` in C
//
// Original definition is following
//
//	RB_FL_TEST_RAW(VALUE obj, VALUE flags)
func RB_FL_TEST_RAW(obj VALUE, flags VALUE) VALUE {
	return VALUE(C.RB_FL_TEST_RAW(C.VALUE(obj), C.VALUE(flags)))
}

// RB_FL_UNSET calls `RB_FL_UNSET` in C
//
// Original definition is following
//
//	RB_FL_UNSET(VALUE obj, VALUE flags)
func RB_FL_UNSET(obj VALUE, flags VALUE) {
	C.RB_FL_UNSET(C.VALUE(obj), C.VALUE(flags))
}

// RB_FL_UNSET_RAW calls `RB_FL_UNSET_RAW` in C
//
// Original definition is following
//
//	RB_FL_UNSET_RAW(VALUE obj, VALUE flags)
func RB_FL_UNSET_RAW(obj VALUE, flags VALUE) {
	C.RB_FL_UNSET_RAW(C.VALUE(obj), C.VALUE(flags))
}

// RB_IMMEDIATE_P calls `RB_IMMEDIATE_P` in C
//
// Original definition is following
//
//	RB_IMMEDIATE_P(VALUE obj)
func RB_IMMEDIATE_P(obj VALUE) Bool {
	return Bool(C.RB_IMMEDIATE_P(C.VALUE(obj)))
}

// RB_INT2FIX calls `RB_INT2FIX` in C
//
// Original definition is following
//
//	RB_INT2FIX(long i)
func RB_INT2FIX(i Long) VALUE {
	return VALUE(C.RB_INT2FIX(C.long(i)))
}

// RB_NIL_OR_UNDEF_P calls `RB_NIL_OR_UNDEF_P` in C
//
// Original definition is following
//
//	RB_NIL_OR_UNDEF_P(VALUE obj)
func RB_NIL_OR_UNDEF_P(obj VALUE) Bool {
	return Bool(C.RB_NIL_OR_UNDEF_P(C.VALUE(obj)))
}

// RB_NIL_P calls `RB_NIL_P` in C
//
// Original definition is following
//
//	RB_NIL_P(VALUE obj)
func RB_NIL_P(obj VALUE) Bool {
	return Bool(C.RB_NIL_P(C.VALUE(obj)))
}

// RB_NUM2UINT calls `RB_NUM2UINT` in C
//
// Original definition is following
//
//	RB_NUM2UINT(VALUE x)
func RB_NUM2UINT(x VALUE) uint {
	return uint(C.RB_NUM2UINT(C.VALUE(x)))
}

// RB_OBJ_FREEZE_RAW calls `RB_OBJ_FREEZE_RAW` in C
//
// Original definition is following
//
//	RB_OBJ_FREEZE_RAW(VALUE obj)
func RB_OBJ_FREEZE_RAW(obj VALUE) {
	C.RB_OBJ_FREEZE_RAW(C.VALUE(obj))
}

// RB_OBJ_FROZEN calls `RB_OBJ_FROZEN` in C
//
// Original definition is following
//
//	RB_OBJ_FROZEN(VALUE obj)
func RB_OBJ_FROZEN(obj VALUE) Bool {
	return Bool(C.RB_OBJ_FROZEN(C.VALUE(obj)))
}

// RB_OBJ_FROZEN_RAW calls `RB_OBJ_FROZEN_RAW` in C
//
// Original definition is following
//
//	RB_OBJ_FROZEN_RAW(VALUE obj)
func RB_OBJ_FROZEN_RAW(obj VALUE) VALUE {
	return VALUE(C.RB_OBJ_FROZEN_RAW(C.VALUE(obj)))
}

// RB_OBJ_PROMOTED calls `RB_OBJ_PROMOTED` in C
//
// Original definition is following
//
//	RB_OBJ_PROMOTED(VALUE obj)
func RB_OBJ_PROMOTED(obj VALUE) Bool {
	return Bool(C.RB_OBJ_PROMOTED(C.VALUE(obj)))
}

// RB_OBJ_PROMOTED_RAW calls `RB_OBJ_PROMOTED_RAW` in C
//
// Original definition is following
//
//	RB_OBJ_PROMOTED_RAW(VALUE obj)
func RB_OBJ_PROMOTED_RAW(obj VALUE) Bool {
	return Bool(C.RB_OBJ_PROMOTED_RAW(C.VALUE(obj)))
}

// RB_SPECIAL_CONST_P calls `RB_SPECIAL_CONST_P` in C
//
// Original definition is following
//
//	RB_SPECIAL_CONST_P(VALUE obj)
func RB_SPECIAL_CONST_P(obj VALUE) Bool {
	return Bool(C.RB_SPECIAL_CONST_P(C.VALUE(obj)))
}

// RB_ST2FIX calls `RB_ST2FIX` in C
//
// Original definition is following
//
//	RB_ST2FIX(st_data_t i)
func RB_ST2FIX(i StDataT) VALUE {
	return VALUE(C.RB_ST2FIX(C.st_data_t(i)))
}

// RB_STATIC_SYM_P calls `RB_STATIC_SYM_P` in C
//
// Original definition is following
//
//	RB_STATIC_SYM_P(VALUE obj)
func RB_STATIC_SYM_P(obj VALUE) Bool {
	return Bool(C.RB_STATIC_SYM_P(C.VALUE(obj)))
}

// RB_SYMBOL_P calls `RB_SYMBOL_P` in C
//
// Original definition is following
//
//	RB_SYMBOL_P(VALUE obj)
func RB_SYMBOL_P(obj VALUE) Bool {
	return Bool(C.RB_SYMBOL_P(C.VALUE(obj)))
}

// RB_TEST calls `RB_TEST` in C
//
// Original definition is following
//
//	RB_TEST(VALUE obj)
func RB_TEST(obj VALUE) Bool {
	return Bool(C.RB_TEST(C.VALUE(obj)))
}

// RB_TYPE_P calls `RB_TYPE_P` in C
//
// Original definition is following
//
//	RB_TYPE_P(VALUE obj, enum ruby_value_type t)
func RB_TYPE_P(obj VALUE, t RubyValueType) Bool {
	return Bool(C.RB_TYPE_P(C.VALUE(obj), C.enum_ruby_value_type(t)))
}

// RB_UNDEF_P calls `RB_UNDEF_P` in C
//
// Original definition is following
//
//	RB_UNDEF_P(VALUE obj)
func RB_UNDEF_P(obj VALUE) Bool {
	return Bool(C.RB_UNDEF_P(C.VALUE(obj)))
}

// RSTRING_END calls `RSTRING_END` in C
//
// Original definition is following
//
//	RSTRING_END(VALUE str)
func RSTRING_END(str VALUE) *Char {
	return (*Char)(C.RSTRING_END(C.VALUE(str)))
}

// RSTRING_LEN calls `RSTRING_LEN` in C
//
// Original definition is following
//
//	RSTRING_LEN(VALUE str)
func RSTRING_LEN(str VALUE) Long {
	return Long(C.RSTRING_LEN(C.VALUE(str)))
}

// RSTRING_LENINT calls `RSTRING_LENINT` in C
//
// Original definition is following
//
//	RSTRING_LENINT(VALUE str)
func RSTRING_LENINT(str VALUE) int {
	return int(C.RSTRING_LENINT(C.VALUE(str)))
}

// RSTRING_PTR calls `RSTRING_PTR` in C
//
// Original definition is following
//
//	RSTRING_PTR(VALUE str)
func RSTRING_PTR(str VALUE) *Char {
	return (*Char)(C.RSTRING_PTR(C.VALUE(str)))
}

// RbArray calls `rb_Array` in C
//
// Original definition is following
//
//	VALUE rb_Array(VALUE val)
func RbArray(val VALUE) VALUE {
	return VALUE(C.rb_Array(C.VALUE(val)))
}

// RbComplex calls `rb_Complex` in C
//
// Original definition is following
//
//	VALUE rb_Complex(VALUE real, VALUE imag)
func RbComplex(real VALUE, imag VALUE) VALUE {
	return VALUE(C.rb_Complex(C.VALUE(real), C.VALUE(imag)))
}

// RbFloat calls `rb_Float` in C
//
// Original definition is following
//
//	VALUE rb_Float(VALUE val)
func RbFloat(val VALUE) VALUE {
	return VALUE(C.rb_Float(C.VALUE(val)))
}

// RbInteger calls `rb_Integer` in C
//
// Original definition is following
//
//	VALUE rb_Integer(VALUE val)
func RbInteger(val VALUE) VALUE {
	return VALUE(C.rb_Integer(C.VALUE(val)))
}

// RbRational calls `rb_Rational` in C
//
// Original definition is following
//
//	VALUE rb_Rational(VALUE num, VALUE den)
func RbRational(num VALUE, den VALUE) VALUE {
	return VALUE(C.rb_Rational(C.VALUE(num), C.VALUE(den)))
}

// RbString calls `rb_String` in C
//
// Original definition is following
//
//	VALUE rb_String(VALUE val)
func RbString(val VALUE) VALUE {
	return VALUE(C.rb_String(C.VALUE(val)))
}

// RbAbsintNumwords calls `rb_absint_numwords` in C
//
// Original definition is following
//
//	size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
func RbAbsintNumwords(val VALUE, word_numbits SizeT, nlz_bits_ret *SizeT) SizeT {
	var cNlzBitsRet C.size_t
	ret := SizeT(C.rb_absint_numwords(C.VALUE(val), C.size_t(word_numbits), &cNlzBitsRet))
	*nlz_bits_ret = SizeT(cNlzBitsRet)
	return ret
}

// RbAbsintSinglebitP calls `rb_absint_singlebit_p` in C
//
// Original definition is following
//
//	int rb_absint_singlebit_p(VALUE val)
func RbAbsintSinglebitP(val VALUE) int {
	return int(C.rb_absint_singlebit_p(C.VALUE(val)))
}

// RbAbsintSize calls `rb_absint_size` in C
//
// Original definition is following
//
//	size_t rb_absint_size(VALUE val, int *nlz_bits_ret)
func RbAbsintSize(val VALUE, nlz_bits_ret *int) SizeT {
	var cNlzBitsRet C.int
	ret := SizeT(C.rb_absint_size(C.VALUE(val), &cNlzBitsRet))
	*nlz_bits_ret = int(cNlzBitsRet)
	return ret
}

// RbAddEventHook calls `rb_add_event_hook` in C
//
// Original definition is following
//
//	void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
func RbAddEventHook(fun RbEventHookFuncT, events RbEventFlagT, data VALUE) {
	C.rb_add_event_hook(C.rb_event_hook_func_t(fun), C.rb_event_flag_t(events), C.VALUE(data))
}

// RbAlias calls `rb_alias` in C
//
// Original definition is following
//
//	void rb_alias(VALUE klass, ID dst, ID src)
func RbAlias(klass VALUE, dst ID, src ID) {
	C.rb_alias(C.VALUE(klass), C.ID(dst), C.ID(src))
}

// RbAliasVariable calls `rb_alias_variable` in C
//
// Original definition is following
//
//	void rb_alias_variable(ID dst, ID src)
func RbAliasVariable(dst ID, src ID) {
	C.rb_alias_variable(C.ID(dst), C.ID(src))
}

// RbAllocTmpBuffer calls `rb_alloc_tmp_buffer` in C
//
// Original definition is following
//
//	void *rb_alloc_tmp_buffer(volatile VALUE *store, long len)
func RbAllocTmpBuffer(store *VALUE, len Long) unsafe.Pointer {
	var cStore C.VALUE
	ret := unsafe.Pointer(C.rb_alloc_tmp_buffer(&cStore, C.long(len)))
	*store = VALUE(cStore)
	return ret
}

// RbAllocTmpBuffer2 calls `rb_alloc_tmp_buffer2` in C
//
// Original definition is following
//
//	rb_alloc_tmp_buffer2(volatile VALUE *store, long count, size_t elsize)
func RbAllocTmpBuffer2(store *VALUE, count Long, elsize SizeT) unsafe.Pointer {
	var cStore C.VALUE
	ret := unsafe.Pointer(C.rb_alloc_tmp_buffer2(&cStore, C.long(count), C.size_t(elsize)))
	*store = VALUE(cStore)
	return ret
}

// RbAllocTmpBufferWithCount calls `rb_alloc_tmp_buffer_with_count` in C
//
// Original definition is following
//
//	void *rb_alloc_tmp_buffer_with_count(volatile VALUE *store, size_t len,size_t count)
func RbAllocTmpBufferWithCount(store *VALUE, len SizeT, count SizeT) unsafe.Pointer {
	var cStore C.VALUE
	ret := unsafe.Pointer(C.rb_alloc_tmp_buffer_with_count(&cStore, C.size_t(len), C.size_t(count)))
	*store = VALUE(cStore)
	return ret
}

// RbAnyToS calls `rb_any_to_s` in C
//
// Original definition is following
//
//	VALUE rb_any_to_s(VALUE obj)
func RbAnyToS(obj VALUE) VALUE {
	return VALUE(C.rb_any_to_s(C.VALUE(obj)))
}

// RbApply calls `rb_apply` in C
//
// Original definition is following
//
//	VALUE rb_apply(VALUE recv, ID mid, VALUE args)
func RbApply(recv VALUE, mid ID, args VALUE) VALUE {
	return VALUE(C.rb_apply(C.VALUE(recv), C.ID(mid), C.VALUE(args)))
}

// RbArithmeticSequenceBegLenStep calls `rb_arithmetic_sequence_beg_len_step` in C
//
// Original definition is following
//
//	VALUE rb_arithmetic_sequence_beg_len_step(VALUE as, long *begp, long *lenp, long *stepp, long len, int err)
func RbArithmeticSequenceBegLenStep(as VALUE, begp *Long, lenp *Long, stepp *Long, len Long, err int) VALUE {
	var cBegp C.long
	var cLenp C.long
	var cStepp C.long
	ret := VALUE(C.rb_arithmetic_sequence_beg_len_step(C.VALUE(as), &cBegp, &cLenp, &cStepp, C.long(len), C.int(err)))
	*begp = Long(cBegp)
	*lenp = Long(cLenp)
	*stepp = Long(cStepp)
	return ret
}

// RbArithmeticSequenceExtract calls `rb_arithmetic_sequence_extract` in C
//
// Original definition is following
//
//	int rb_arithmetic_sequence_extract(VALUE as, rb_arithmetic_sequence_components_t *buf)
func RbArithmeticSequenceExtract(as VALUE, buf *RbArithmeticSequenceComponentsT) int {
	var cBuf C.rb_arithmetic_sequence_components_t
	ret := int(C.rb_arithmetic_sequence_extract(C.VALUE(as), &cBuf))
	*buf = RbArithmeticSequenceComponentsT(cBuf)
	return ret
}

// RbArrayConstPtr calls `rb_array_const_ptr` in C
//
// Original definition is following
//
//	rb_array_const_ptr(VALUE a)
func RbArrayConstPtr(a VALUE) *VALUE {
	return (*VALUE)(C.rb_array_const_ptr(C.VALUE(a)))
}

// RbArrayLen calls `rb_array_len` in C
//
// Original definition is following
//
//	rb_array_len(VALUE a)
func RbArrayLen(a VALUE) Long {
	return Long(C.rb_array_len(C.VALUE(a)))
}

// RbAryAref calls `rb_ary_aref` in C
//
// Original definition is following
//
//	VALUE rb_ary_aref(int argc, const VALUE *argv, VALUE ary)
func RbAryAref(argc int, argv *VALUE, ary VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_ary_aref(C.int(argc), &cArgv, C.VALUE(ary)))
	*argv = VALUE(cArgv)
	return ret
}

// RbAryAssoc calls `rb_ary_assoc` in C
//
// Original definition is following
//
//	VALUE rb_ary_assoc(VALUE alist, VALUE key)
func RbAryAssoc(alist VALUE, key VALUE) VALUE {
	return VALUE(C.rb_ary_assoc(C.VALUE(alist), C.VALUE(key)))
}

// RbAryCat calls `rb_ary_cat` in C
//
// Original definition is following
//
//	VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len)
func RbAryCat(ary VALUE, train *VALUE, len Long) VALUE {
	var cTrain C.VALUE
	ret := VALUE(C.rb_ary_cat(C.VALUE(ary), &cTrain, C.long(len)))
	*train = VALUE(cTrain)
	return ret
}

// RbAryClear calls `rb_ary_clear` in C
//
// Original definition is following
//
//	VALUE rb_ary_clear(VALUE ary)
func RbAryClear(ary VALUE) VALUE {
	return VALUE(C.rb_ary_clear(C.VALUE(ary)))
}

// RbAryCmp calls `rb_ary_cmp` in C
//
// Original definition is following
//
//	VALUE rb_ary_cmp(VALUE lhs, VALUE rhs)
func RbAryCmp(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_ary_cmp(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbAryConcat calls `rb_ary_concat` in C
//
// Original definition is following
//
//	VALUE rb_ary_concat(VALUE lhs, VALUE rhs)
func RbAryConcat(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_ary_concat(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbAryDelete calls `rb_ary_delete` in C
//
// Original definition is following
//
//	VALUE rb_ary_delete(VALUE ary, VALUE elem)
func RbAryDelete(ary VALUE, elem VALUE) VALUE {
	return VALUE(C.rb_ary_delete(C.VALUE(ary), C.VALUE(elem)))
}

// RbAryDeleteAt calls `rb_ary_delete_at` in C
//
// Original definition is following
//
//	VALUE rb_ary_delete_at(VALUE ary, long pos)
func RbAryDeleteAt(ary VALUE, pos Long) VALUE {
	return VALUE(C.rb_ary_delete_at(C.VALUE(ary), C.long(pos)))
}

// RbAryDup calls `rb_ary_dup` in C
//
// Original definition is following
//
//	VALUE rb_ary_dup(VALUE ary)
func RbAryDup(ary VALUE) VALUE {
	return VALUE(C.rb_ary_dup(C.VALUE(ary)))
}

// RbAryEach calls `rb_ary_each` in C
//
// Original definition is following
//
//	VALUE rb_ary_each(VALUE ary)
func RbAryEach(ary VALUE) VALUE {
	return VALUE(C.rb_ary_each(C.VALUE(ary)))
}

// RbAryEntry calls `rb_ary_entry` in C
//
// Original definition is following
//
//	VALUE rb_ary_entry(VALUE ary, long off)
func RbAryEntry(ary VALUE, off Long) VALUE {
	return VALUE(C.rb_ary_entry(C.VALUE(ary), C.long(off)))
}

// RbAryFree calls `rb_ary_free` in C
//
// Original definition is following
//
//	void rb_ary_free(VALUE ary)
func RbAryFree(ary VALUE) {
	C.rb_ary_free(C.VALUE(ary))
}

// RbAryFreeze calls `rb_ary_freeze` in C
//
// Original definition is following
//
//	VALUE rb_ary_freeze(VALUE obj)
func RbAryFreeze(obj VALUE) VALUE {
	return VALUE(C.rb_ary_freeze(C.VALUE(obj)))
}

// RbAryHiddenNew calls `rb_ary_hidden_new` in C
//
// Original definition is following
//
//	VALUE rb_ary_hidden_new(long capa)
func RbAryHiddenNew(capa Long) VALUE {
	return VALUE(C.rb_ary_hidden_new(C.long(capa)))
}

// RbAryIncludes calls `rb_ary_includes` in C
//
// Original definition is following
//
//	VALUE rb_ary_includes(VALUE ary, VALUE elem)
func RbAryIncludes(ary VALUE, elem VALUE) VALUE {
	return VALUE(C.rb_ary_includes(C.VALUE(ary), C.VALUE(elem)))
}

// RbAryJoin calls `rb_ary_join` in C
//
// Original definition is following
//
//	VALUE rb_ary_join(VALUE ary, VALUE sep)
func RbAryJoin(ary VALUE, sep VALUE) VALUE {
	return VALUE(C.rb_ary_join(C.VALUE(ary), C.VALUE(sep)))
}

// RbAryModify calls `rb_ary_modify` in C
//
// Original definition is following
//
//	void rb_ary_modify(VALUE ary)
func RbAryModify(ary VALUE) {
	C.rb_ary_modify(C.VALUE(ary))
}

// RbAryNew calls `rb_ary_new` in C
//
// Original definition is following
//
//	VALUE rb_ary_new(void)
func RbAryNew() VALUE {
	return VALUE(C.rb_ary_new())
}

// RbAryNewCapa calls `rb_ary_new_capa` in C
//
// Original definition is following
//
//	VALUE rb_ary_new_capa(long capa)
func RbAryNewCapa(capa Long) VALUE {
	return VALUE(C.rb_ary_new_capa(C.long(capa)))
}

// RbAryNewFromValues calls `rb_ary_new_from_values` in C
//
// Original definition is following
//
//	VALUE rb_ary_new_from_values(long n, const VALUE *elts)
func RbAryNewFromValues(n Long, elts *VALUE) VALUE {
	var cElts C.VALUE
	ret := VALUE(C.rb_ary_new_from_values(C.long(n), &cElts))
	*elts = VALUE(cElts)
	return ret
}

// RbAryPlus calls `rb_ary_plus` in C
//
// Original definition is following
//
//	VALUE rb_ary_plus(VALUE lhs, VALUE rhs)
func RbAryPlus(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_ary_plus(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbAryPop calls `rb_ary_pop` in C
//
// Original definition is following
//
//	VALUE rb_ary_pop(VALUE ary)
func RbAryPop(ary VALUE) VALUE {
	return VALUE(C.rb_ary_pop(C.VALUE(ary)))
}

// RbAryPtrUseEnd calls `rb_ary_ptr_use_end` in C
//
// Original definition is following
//
//	void rb_ary_ptr_use_end(VALUE a)
func RbAryPtrUseEnd(a VALUE) {
	C.rb_ary_ptr_use_end(C.VALUE(a))
}

// RbAryPtrUseStart calls `rb_ary_ptr_use_start` in C
//
// Original definition is following
//
//	VALUE *rb_ary_ptr_use_start(VALUE ary)
func RbAryPtrUseStart(ary VALUE) *VALUE {
	return (*VALUE)(C.rb_ary_ptr_use_start(C.VALUE(ary)))
}

// RbAryPush calls `rb_ary_push` in C
//
// Original definition is following
//
//	VALUE rb_ary_push(VALUE ary, VALUE elem)
func RbAryPush(ary VALUE, elem VALUE) VALUE {
	return VALUE(C.rb_ary_push(C.VALUE(ary), C.VALUE(elem)))
}

// RbAryRassoc calls `rb_ary_rassoc` in C
//
// Original definition is following
//
//	VALUE rb_ary_rassoc(VALUE alist, VALUE key)
func RbAryRassoc(alist VALUE, key VALUE) VALUE {
	return VALUE(C.rb_ary_rassoc(C.VALUE(alist), C.VALUE(key)))
}

// RbAryReplace calls `rb_ary_replace` in C
//
// Original definition is following
//
//	VALUE rb_ary_replace(VALUE copy, VALUE orig)
func RbAryReplace(copy VALUE, orig VALUE) VALUE {
	return VALUE(C.rb_ary_replace(C.VALUE(copy), C.VALUE(orig)))
}

// RbAryResize calls `rb_ary_resize` in C
//
// Original definition is following
//
//	VALUE rb_ary_resize(VALUE ary, long len)
func RbAryResize(ary VALUE, len Long) VALUE {
	return VALUE(C.rb_ary_resize(C.VALUE(ary), C.long(len)))
}

// RbAryResurrect calls `rb_ary_resurrect` in C
//
// Original definition is following
//
//	VALUE rb_ary_resurrect(VALUE ary)
func RbAryResurrect(ary VALUE) VALUE {
	return VALUE(C.rb_ary_resurrect(C.VALUE(ary)))
}

// RbAryReverse calls `rb_ary_reverse` in C
//
// Original definition is following
//
//	VALUE rb_ary_reverse(VALUE ary)
func RbAryReverse(ary VALUE) VALUE {
	return VALUE(C.rb_ary_reverse(C.VALUE(ary)))
}

// RbAryRotate calls `rb_ary_rotate` in C
//
// Original definition is following
//
//	VALUE rb_ary_rotate(VALUE ary, long rot)
func RbAryRotate(ary VALUE, rot Long) VALUE {
	return VALUE(C.rb_ary_rotate(C.VALUE(ary), C.long(rot)))
}

// RbArySharedWithP calls `rb_ary_shared_with_p` in C
//
// Original definition is following
//
//	VALUE rb_ary_shared_with_p(VALUE lhs, VALUE rhs)
func RbArySharedWithP(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_ary_shared_with_p(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbAryShift calls `rb_ary_shift` in C
//
// Original definition is following
//
//	VALUE rb_ary_shift(VALUE ary)
func RbAryShift(ary VALUE) VALUE {
	return VALUE(C.rb_ary_shift(C.VALUE(ary)))
}

// RbArySort calls `rb_ary_sort` in C
//
// Original definition is following
//
//	VALUE rb_ary_sort(VALUE ary)
func RbArySort(ary VALUE) VALUE {
	return VALUE(C.rb_ary_sort(C.VALUE(ary)))
}

// RbArySortBang calls `rb_ary_sort_bang` in C
//
// Original definition is following
//
//	VALUE rb_ary_sort_bang(VALUE ary)
func RbArySortBang(ary VALUE) VALUE {
	return VALUE(C.rb_ary_sort_bang(C.VALUE(ary)))
}

// RbAryStore calls `rb_ary_store` in C
//
// Original definition is following
//
//	void rb_ary_store(VALUE ary, long key, VALUE val)
func RbAryStore(ary VALUE, key Long, val VALUE) {
	C.rb_ary_store(C.VALUE(ary), C.long(key), C.VALUE(val))
}

// RbArySubseq calls `rb_ary_subseq` in C
//
// Original definition is following
//
//	VALUE rb_ary_subseq(VALUE ary, long beg, long len)
func RbArySubseq(ary VALUE, beg Long, len Long) VALUE {
	return VALUE(C.rb_ary_subseq(C.VALUE(ary), C.long(beg), C.long(len)))
}

// RbAryToAry calls `rb_ary_to_ary` in C
//
// Original definition is following
//
//	VALUE rb_ary_to_ary(VALUE obj)
func RbAryToAry(obj VALUE) VALUE {
	return VALUE(C.rb_ary_to_ary(C.VALUE(obj)))
}

// RbAryToS calls `rb_ary_to_s` in C
//
// Original definition is following
//
//	VALUE rb_ary_to_s(VALUE ary)
func RbAryToS(ary VALUE) VALUE {
	return VALUE(C.rb_ary_to_s(C.VALUE(ary)))
}

// RbAryUnshift calls `rb_ary_unshift` in C
//
// Original definition is following
//
//	VALUE rb_ary_unshift(VALUE ary, VALUE elem)
func RbAryUnshift(ary VALUE, elem VALUE) VALUE {
	return VALUE(C.rb_ary_unshift(C.VALUE(ary), C.VALUE(elem)))
}

// RbAssertFailure calls `rb_assert_failure` in C
//
// Original definition is following
//
//	void rb_assert_failure(const char *file, int line, const char *name, const char *expr)
func RbAssertFailure(file string, line int, name string, expr string) {
	charFile, cleanCharfile := string2Char(file)
	defer cleanCharfile()

	charName, cleanCharname := string2Char(name)
	defer cleanCharname()

	charExpr, cleanCharexpr := string2Char(expr)
	defer cleanCharexpr()

	C.rb_assert_failure(charFile, C.int(line), charName, charExpr)
}

// RbAssocNew calls `rb_assoc_new` in C
//
// Original definition is following
//
//	VALUE rb_assoc_new(VALUE car, VALUE cdr)
func RbAssocNew(car VALUE, cdr VALUE) VALUE {
	return VALUE(C.rb_assoc_new(C.VALUE(car), C.VALUE(cdr)))
}

// RbAttr calls `rb_attr` in C
//
// Original definition is following
//
//	void rb_attr(VALUE klass, ID name, int need_reader, int need_writer, int honour_visibility)
func RbAttr(klass VALUE, name ID, need_reader int, need_writer int, honour_visibility int) {
	C.rb_attr(C.VALUE(klass), C.ID(name), C.int(need_reader), C.int(need_writer), C.int(honour_visibility))
}

// RbAttrGet calls `rb_attr_get` in C
//
// Original definition is following
//
//	VALUE rb_attr_get(VALUE obj, ID name)
func RbAttrGet(obj VALUE, name ID) VALUE {
	return VALUE(C.rb_attr_get(C.VALUE(obj), C.ID(name)))
}

// RbAutoloadLoad calls `rb_autoload_load` in C
//
// Original definition is following
//
//	VALUE rb_autoload_load(VALUE space, ID name)
func RbAutoloadLoad(space VALUE, name ID) VALUE {
	return VALUE(C.rb_autoload_load(C.VALUE(space), C.ID(name)))
}

// RbAutoloadP calls `rb_autoload_p` in C
//
// Original definition is following
//
//	VALUE rb_autoload_p(VALUE space, ID name)
func RbAutoloadP(space VALUE, name ID) VALUE {
	return VALUE(C.rb_autoload_p(C.VALUE(space), C.ID(name)))
}

// RbBackrefGet calls `rb_backref_get` in C
//
// Original definition is following
//
//	VALUE rb_backref_get(void)
func RbBackrefGet() VALUE {
	return VALUE(C.rb_backref_get())
}

// RbBackrefSet calls `rb_backref_set` in C
//
// Original definition is following
//
//	void rb_backref_set(VALUE md)
func RbBackrefSet(md VALUE) {
	C.rb_backref_set(C.VALUE(md))
}

// RbBacktrace calls `rb_backtrace` in C
//
// Original definition is following
//
//	void rb_backtrace(void)
func RbBacktrace() {
	C.rb_backtrace()
}

// RbBig2Dbl calls `rb_big2dbl` in C
//
// Original definition is following
//
//	double rb_big2dbl(VALUE x)
func RbBig2Dbl(x VALUE) Double {
	return Double(C.rb_big2dbl(C.VALUE(x)))
}

// RbBig2Ll calls `rb_big2ll` in C
//
// Original definition is following
//
//	rb_big2ll(VALUE)
func RbBig2Ll(arg1 VALUE) Longlong {
	return Longlong(C.rb_big2ll(C.VALUE(arg1)))
}

// RbBig2Long calls `rb_big2long` in C
//
// Original definition is following
//
//	long rb_big2long(VALUE x)
func RbBig2Long(x VALUE) Long {
	return Long(C.rb_big2long(C.VALUE(x)))
}

// RbBig2Str calls `rb_big2str` in C
//
// Original definition is following
//
//	VALUE rb_big2str(VALUE x, int base)
func RbBig2Str(x VALUE, base int) VALUE {
	return VALUE(C.rb_big2str(C.VALUE(x), C.int(base)))
}

// RbBig2Ull calls `rb_big2ull` in C
//
// Original definition is following
//
//	rb_big2ull(VALUE)
func RbBig2Ull(arg1 VALUE) Ulonglong {
	return Ulonglong(C.rb_big2ull(C.VALUE(arg1)))
}

// RbBig2Ulong calls `rb_big2ulong` in C
//
// Original definition is following
//
//	unsigned long rb_big2ulong(VALUE x)
func RbBig2Ulong(x VALUE) uint {
	return uint(C.rb_big2ulong(C.VALUE(x)))
}

// RbBig2Comp calls `rb_big_2comp` in C
//
// Original definition is following
//
//	void rb_big_2comp(VALUE num)
func RbBig2Comp(num VALUE) {
	C.rb_big_2comp(C.VALUE(num))
}

// RbBigAnd calls `rb_big_and` in C
//
// Original definition is following
//
//	VALUE rb_big_and(VALUE x, VALUE y)
func RbBigAnd(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_and(C.VALUE(x), C.VALUE(y)))
}

// RbBigClone calls `rb_big_clone` in C
//
// Original definition is following
//
//	VALUE rb_big_clone(VALUE num)
func RbBigClone(num VALUE) VALUE {
	return VALUE(C.rb_big_clone(C.VALUE(num)))
}

// RbBigCmp calls `rb_big_cmp` in C
//
// Original definition is following
//
//	VALUE rb_big_cmp(VALUE lhs, VALUE rhs)
func RbBigCmp(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_big_cmp(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbBigDiv calls `rb_big_div` in C
//
// Original definition is following
//
//	VALUE rb_big_div(VALUE x, VALUE y)
func RbBigDiv(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_div(C.VALUE(x), C.VALUE(y)))
}

// RbBigDivmod calls `rb_big_divmod` in C
//
// Original definition is following
//
//	VALUE rb_big_divmod(VALUE x, VALUE y)
func RbBigDivmod(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_divmod(C.VALUE(x), C.VALUE(y)))
}

// RbBigEq calls `rb_big_eq` in C
//
// Original definition is following
//
//	VALUE rb_big_eq(VALUE lhs, VALUE rhs)
func RbBigEq(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_big_eq(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbBigEql calls `rb_big_eql` in C
//
// Original definition is following
//
//	VALUE rb_big_eql(VALUE lhs, VALUE rhs)
func RbBigEql(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_big_eql(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbBigIdiv calls `rb_big_idiv` in C
//
// Original definition is following
//
//	VALUE rb_big_idiv(VALUE x, VALUE y)
func RbBigIdiv(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_idiv(C.VALUE(x), C.VALUE(y)))
}

// RbBigLshift calls `rb_big_lshift` in C
//
// Original definition is following
//
//	VALUE rb_big_lshift(VALUE x, VALUE y)
func RbBigLshift(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_lshift(C.VALUE(x), C.VALUE(y)))
}

// RbBigMinus calls `rb_big_minus` in C
//
// Original definition is following
//
//	VALUE rb_big_minus(VALUE x, VALUE y)
func RbBigMinus(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_minus(C.VALUE(x), C.VALUE(y)))
}

// RbBigModulo calls `rb_big_modulo` in C
//
// Original definition is following
//
//	VALUE rb_big_modulo(VALUE x, VALUE y)
func RbBigModulo(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_modulo(C.VALUE(x), C.VALUE(y)))
}

// RbBigMul calls `rb_big_mul` in C
//
// Original definition is following
//
//	VALUE rb_big_mul(VALUE x, VALUE y)
func RbBigMul(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_mul(C.VALUE(x), C.VALUE(y)))
}

// RbBigNew calls `rb_big_new` in C
//
// Original definition is following
//
//	VALUE rb_big_new(size_t len, int sign)
func RbBigNew(len SizeT, sign int) VALUE {
	return VALUE(C.rb_big_new(C.size_t(len), C.int(sign)))
}

// RbBigNorm calls `rb_big_norm` in C
//
// Original definition is following
//
//	VALUE rb_big_norm(VALUE x)
func RbBigNorm(x VALUE) VALUE {
	return VALUE(C.rb_big_norm(C.VALUE(x)))
}

// RbBigOr calls `rb_big_or` in C
//
// Original definition is following
//
//	VALUE rb_big_or(VALUE x, VALUE y)
func RbBigOr(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_or(C.VALUE(x), C.VALUE(y)))
}

// RbBigPack calls `rb_big_pack` in C
//
// Original definition is following
//
//	void rb_big_pack(VALUE val, unsigned long *buf, long num_longs)
func RbBigPack(val VALUE, buf *uint, num_longs Long) {
	var cBuf C.ulong
	C.rb_big_pack(C.VALUE(val), &cBuf, C.long(num_longs))
	*buf = uint(cBuf)
}

// RbBigPlus calls `rb_big_plus` in C
//
// Original definition is following
//
//	VALUE rb_big_plus(VALUE x, VALUE y)
func RbBigPlus(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_plus(C.VALUE(x), C.VALUE(y)))
}

// RbBigPow calls `rb_big_pow` in C
//
// Original definition is following
//
//	VALUE rb_big_pow(VALUE x, VALUE y)
func RbBigPow(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_pow(C.VALUE(x), C.VALUE(y)))
}

// RbBigResize calls `rb_big_resize` in C
//
// Original definition is following
//
//	void rb_big_resize(VALUE big, size_t len)
func RbBigResize(big VALUE, len SizeT) {
	C.rb_big_resize(C.VALUE(big), C.size_t(len))
}

// RbBigRshift calls `rb_big_rshift` in C
//
// Original definition is following
//
//	VALUE rb_big_rshift(VALUE x, VALUE y)
func RbBigRshift(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_rshift(C.VALUE(x), C.VALUE(y)))
}

// RbBigSign calls `rb_big_sign` in C
//
// Original definition is following
//
//	int rb_big_sign(VALUE num)
func RbBigSign(num VALUE) int {
	return int(C.rb_big_sign(C.VALUE(num)))
}

// RbBigUnpack calls `rb_big_unpack` in C
//
// Original definition is following
//
//	VALUE rb_big_unpack(unsigned long *buf, long num_longs)
func RbBigUnpack(buf *uint, num_longs Long) VALUE {
	var cBuf C.ulong
	ret := VALUE(C.rb_big_unpack(&cBuf, C.long(num_longs)))
	*buf = uint(cBuf)
	return ret
}

// RbBigXor calls `rb_big_xor` in C
//
// Original definition is following
//
//	VALUE rb_big_xor(VALUE x, VALUE y)
func RbBigXor(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_big_xor(C.VALUE(x), C.VALUE(y)))
}

// RbBigzeroP calls `rb_bigzero_p` in C
//
// Original definition is following
//
//	int rb_bigzero_p(VALUE x)
func RbBigzeroP(x VALUE) int {
	return int(C.rb_bigzero_p(C.VALUE(x)))
}

// RbBindingNew calls `rb_binding_new` in C
//
// Original definition is following
//
//	VALUE rb_binding_new(void)
func RbBindingNew() VALUE {
	return VALUE(C.rb_binding_new())
}

// RbBlockCall calls `rb_block_call` in C
//
// Original definition is following
//
//	VALUE rb_block_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t proc, VALUE data2)
func RbBlockCall(obj VALUE, mid ID, argc int, argv *VALUE, proc RbBlockCallFuncT, data2 VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_block_call(C.VALUE(obj), C.ID(mid), C.int(argc), &cArgv, C.rb_block_call_func_t(proc), C.VALUE(data2)))
	*argv = VALUE(cArgv)
	return ret
}

// RbBlockCallKw calls `rb_block_call_kw` in C
//
// Original definition is following
//
//	VALUE rb_block_call_kw(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t proc, VALUE data2, int kw_splat)
func RbBlockCallKw(obj VALUE, mid ID, argc int, argv *VALUE, proc RbBlockCallFuncT, data2 VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_block_call_kw(C.VALUE(obj), C.ID(mid), C.int(argc), &cArgv, C.rb_block_call_func_t(proc), C.VALUE(data2), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbBlockGivenP calls `rb_block_given_p` in C
//
// Original definition is following
//
//	int rb_block_given_p(void)
func RbBlockGivenP() int {
	return int(C.rb_block_given_p())
}

// RbBlockLambda calls `rb_block_lambda` in C
//
// Original definition is following
//
//	VALUE rb_block_lambda(void)
func RbBlockLambda() VALUE {
	return VALUE(C.rb_block_lambda())
}

// RbBlockProc calls `rb_block_proc` in C
//
// Original definition is following
//
//	VALUE rb_block_proc(void)
func RbBlockProc() VALUE {
	return VALUE(C.rb_block_proc())
}

// RbBugErrno calls `rb_bug_errno` in C
//
// Original definition is following
//
//	void rb_bug_errno(const char *msg, int err)
func RbBugErrno(msg string, err int) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_bug_errno(char, C.int(err))
}

// RbCallSuper calls `rb_call_super` in C
//
// Original definition is following
//
//	VALUE rb_call_super(int argc, const VALUE *argv)
func RbCallSuper(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_call_super(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbCallSuperKw calls `rb_call_super_kw` in C
//
// Original definition is following
//
//	VALUE rb_call_super_kw(int argc, const VALUE *argv, int kw_splat)
func RbCallSuperKw(argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_call_super_kw(C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbCatch calls `rb_catch` in C
//
// Original definition is following
//
//	VALUE rb_catch(const char *tag, rb_block_call_func_t func, VALUE data)
func RbCatch(tag string, fun RbBlockCallFuncT, data VALUE) VALUE {
	char, clean := string2Char(tag)
	defer clean()

	return VALUE(C.rb_catch(char, C.rb_block_call_func_t(fun), C.VALUE(data)))
}

// RbCatchObj calls `rb_catch_obj` in C
//
// Original definition is following
//
//	VALUE rb_catch_obj(VALUE tag, rb_block_call_func_t func, VALUE data)
func RbCatchObj(tag VALUE, fun RbBlockCallFuncT, data VALUE) VALUE {
	return VALUE(C.rb_catch_obj(C.VALUE(tag), C.rb_block_call_func_t(fun), C.VALUE(data)))
}

// RbCheckArity calls `rb_check_arity` in C
//
// Original definition is following
//
//	rb_check_arity(int argc, int min, int max)
func RbCheckArity(argc int, min int, max int) int {
	return int(C.rb_check_arity(C.int(argc), C.int(min), C.int(max)))
}

// RbCheckArrayType calls `rb_check_array_type` in C
//
// Original definition is following
//
//	VALUE rb_check_array_type(VALUE obj)
func RbCheckArrayType(obj VALUE) VALUE {
	return VALUE(C.rb_check_array_type(C.VALUE(obj)))
}

// RbCheckConvertType calls `rb_check_convert_type` in C
//
// Original definition is following
//
//	VALUE rb_check_convert_type(VALUE val, int type, const char *name, const char *mid)
func RbCheckConvertType(val VALUE, t int, name string, mid string) VALUE {
	charName, cleanCharname := string2Char(name)
	defer cleanCharname()

	charMid, cleanCharmid := string2Char(mid)
	defer cleanCharmid()

	return VALUE(C.rb_check_convert_type(C.VALUE(val), C.int(t), charName, charMid))
}

// RbCheckCopyable calls `rb_check_copyable` in C
//
// Original definition is following
//
//	void rb_check_copyable(VALUE obj, VALUE orig)
func RbCheckCopyable(obj VALUE, orig VALUE) {
	C.rb_check_copyable(C.VALUE(obj), C.VALUE(orig))
}

// RbCheckFrozen calls `rb_check_frozen` in C
//
// Original definition is following
//
//	void rb_check_frozen(VALUE obj)
func RbCheckFrozen(obj VALUE) {
	C.rb_check_frozen(C.VALUE(obj))
}

// RbCheckFrozenInline calls `rb_check_frozen_inline` in C
//
// Original definition is following
//
//	rb_check_frozen_inline(VALUE obj)
func RbCheckFrozenInline(obj VALUE) {
	C.rb_check_frozen_inline(C.VALUE(obj))
}

// RbCheckFuncall calls `rb_check_funcall` in C
//
// Original definition is following
//
//	VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
func RbCheckFuncall(recv VALUE, mid ID, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_check_funcall(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbCheckFuncallKw calls `rb_check_funcall_kw` in C
//
// Original definition is following
//
//	VALUE rb_check_funcall_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
func RbCheckFuncallKw(recv VALUE, mid ID, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_check_funcall_kw(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbCheckHashType calls `rb_check_hash_type` in C
//
// Original definition is following
//
//	VALUE rb_check_hash_type(VALUE obj)
func RbCheckHashType(obj VALUE) VALUE {
	return VALUE(C.rb_check_hash_type(C.VALUE(obj)))
}

// RbCheckId calls `rb_check_id` in C
//
// Original definition is following
//
//	ID rb_check_id(volatile VALUE *namep)
func RbCheckId(namep *VALUE) ID {
	var cNamep C.VALUE
	ret := ID(C.rb_check_id(&cNamep))
	*namep = VALUE(cNamep)
	return ret
}

// RbCheckInheritable calls `rb_check_inheritable` in C
//
// Original definition is following
//
//	void rb_check_inheritable(VALUE super)
func RbCheckInheritable(super VALUE) {
	C.rb_check_inheritable(C.VALUE(super))
}

// RbCheckStringType calls `rb_check_string_type` in C
//
// Original definition is following
//
//	VALUE rb_check_string_type(VALUE obj)
func RbCheckStringType(obj VALUE) VALUE {
	return VALUE(C.rb_check_string_type(C.VALUE(obj)))
}

// RbCheckSymbol calls `rb_check_symbol` in C
//
// Original definition is following
//
//	VALUE rb_check_symbol(volatile VALUE *namep)
func RbCheckSymbol(namep *VALUE) VALUE {
	var cNamep C.VALUE
	ret := VALUE(C.rb_check_symbol(&cNamep))
	*namep = VALUE(cNamep)
	return ret
}

// RbCheckToFloat calls `rb_check_to_float` in C
//
// Original definition is following
//
//	VALUE rb_check_to_float(VALUE val)
func RbCheckToFloat(val VALUE) VALUE {
	return VALUE(C.rb_check_to_float(C.VALUE(val)))
}

// RbCheckToInt calls `rb_check_to_int` in C
//
// Original definition is following
//
//	VALUE rb_check_to_int(VALUE val)
func RbCheckToInt(val VALUE) VALUE {
	return VALUE(C.rb_check_to_int(C.VALUE(val)))
}

// RbCheckToInteger calls `rb_check_to_integer` in C
//
// Original definition is following
//
//	VALUE rb_check_to_integer(VALUE val, const char *mid)
func RbCheckToInteger(val VALUE, mid string) VALUE {
	char, clean := string2Char(mid)
	defer clean()

	return VALUE(C.rb_check_to_integer(C.VALUE(val), char))
}

// RbCheckType calls `rb_check_type` in C
//
// Original definition is following
//
//	void rb_check_type(VALUE obj, int t)
func RbCheckType(obj VALUE, t int) {
	C.rb_check_type(C.VALUE(obj), C.int(t))
}

// RbCheckTypeddata calls `rb_check_typeddata` in C
//
// Original definition is following
//
//	void *rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
func RbCheckTypeddata(obj VALUE, data_type *RbDataTypeT) unsafe.Pointer {
	var cDataType C.rb_data_type_t
	ret := unsafe.Pointer(C.rb_check_typeddata(C.VALUE(obj), &cDataType))
	*data_type = RbDataTypeT(cDataType)
	return ret
}

// RbClass2Name calls `rb_class2name` in C
//
// Original definition is following
//
//	const char *rb_class2name(VALUE klass)
func RbClass2Name(klass VALUE) string {
	return char2String(C.rb_class2name(C.VALUE(klass)))
}

// RbClassAttachedObject calls `rb_class_attached_object` in C
//
// Original definition is following
//
//	VALUE rb_class_attached_object(VALUE klass)
func RbClassAttachedObject(klass VALUE) VALUE {
	return VALUE(C.rb_class_attached_object(C.VALUE(klass)))
}

// RbClassGetSuperclass calls `rb_class_get_superclass` in C
//
// Original definition is following
//
//	VALUE rb_class_get_superclass(VALUE klass)
func RbClassGetSuperclass(klass VALUE) VALUE {
	return VALUE(C.rb_class_get_superclass(C.VALUE(klass)))
}

// RbClassInheritedP calls `rb_class_inherited_p` in C
//
// Original definition is following
//
//	VALUE rb_class_inherited_p(VALUE scion, VALUE ascendant)
func RbClassInheritedP(scion VALUE, ascendant VALUE) VALUE {
	return VALUE(C.rb_class_inherited_p(C.VALUE(scion), C.VALUE(ascendant)))
}

// RbClassInstanceMethods calls `rb_class_instance_methods` in C
//
// Original definition is following
//
//	VALUE rb_class_instance_methods(int argc, const VALUE *argv, VALUE mod)
func RbClassInstanceMethods(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_instance_methods(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassName calls `rb_class_name` in C
//
// Original definition is following
//
//	VALUE rb_class_name(VALUE obj)
func RbClassName(obj VALUE) VALUE {
	return VALUE(C.rb_class_name(C.VALUE(obj)))
}

// RbClassNew calls `rb_class_new` in C
//
// Original definition is following
//
//	VALUE rb_class_new(VALUE super)
func RbClassNew(super VALUE) VALUE {
	return VALUE(C.rb_class_new(C.VALUE(super)))
}

// RbClassNewInstance calls `rb_class_new_instance` in C
//
// Original definition is following
//
//	VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
func RbClassNewInstance(argc int, argv *VALUE, klass VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_new_instance(C.int(argc), &cArgv, C.VALUE(klass)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassNewInstanceKw calls `rb_class_new_instance_kw` in C
//
// Original definition is following
//
//	VALUE rb_class_new_instance_kw(int argc, const VALUE *argv, VALUE klass, int kw_splat)
func RbClassNewInstanceKw(argc int, argv *VALUE, klass VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_new_instance_kw(C.int(argc), &cArgv, C.VALUE(klass), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassNewInstancePassKw calls `rb_class_new_instance_pass_kw` in C
//
// Original definition is following
//
//	VALUE rb_class_new_instance_pass_kw(int argc, const VALUE *argv, VALUE klass)
func RbClassNewInstancePassKw(argc int, argv *VALUE, klass VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_new_instance_pass_kw(C.int(argc), &cArgv, C.VALUE(klass)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassOf calls `rb_class_of` in C
//
// Original definition is following
//
//	rb_class_of(VALUE obj)
func RbClassOf(obj VALUE) VALUE {
	return VALUE(C.rb_class_of(C.VALUE(obj)))
}

// RbClassPath calls `rb_class_path` in C
//
// Original definition is following
//
//	VALUE rb_class_path(VALUE mod)
func RbClassPath(mod VALUE) VALUE {
	return VALUE(C.rb_class_path(C.VALUE(mod)))
}

// RbClassPathCached calls `rb_class_path_cached` in C
//
// Original definition is following
//
//	VALUE rb_class_path_cached(VALUE mod)
func RbClassPathCached(mod VALUE) VALUE {
	return VALUE(C.rb_class_path_cached(C.VALUE(mod)))
}

// RbClassPrivateInstanceMethods calls `rb_class_private_instance_methods` in C
//
// Original definition is following
//
//	VALUE rb_class_private_instance_methods(int argc, const VALUE *argv, VALUE mod)
func RbClassPrivateInstanceMethods(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_private_instance_methods(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassProtectedInstanceMethods calls `rb_class_protected_instance_methods` in C
//
// Original definition is following
//
//	VALUE rb_class_protected_instance_methods(int argc, const VALUE *argv, VALUE mod)
func RbClassProtectedInstanceMethods(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_protected_instance_methods(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassPublicInstanceMethods calls `rb_class_public_instance_methods` in C
//
// Original definition is following
//
//	VALUE rb_class_public_instance_methods(int argc, const VALUE *argv, VALUE mod)
func RbClassPublicInstanceMethods(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_class_public_instance_methods(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbClassReal calls `rb_class_real` in C
//
// Original definition is following
//
//	VALUE rb_class_real(VALUE klass)
func RbClassReal(klass VALUE) VALUE {
	return VALUE(C.rb_class_real(C.VALUE(klass)))
}

// RbClassSubclasses calls `rb_class_subclasses` in C
//
// Original definition is following
//
//	VALUE rb_class_subclasses(VALUE klass)
func RbClassSubclasses(klass VALUE) VALUE {
	return VALUE(C.rb_class_subclasses(C.VALUE(klass)))
}

// RbClassSuperclass calls `rb_class_superclass` in C
//
// Original definition is following
//
//	VALUE rb_class_superclass(VALUE klass)
func RbClassSuperclass(klass VALUE) VALUE {
	return VALUE(C.rb_class_superclass(C.VALUE(klass)))
}

// RbClearConstantCacheForId calls `rb_clear_constant_cache_for_id` in C
//
// Original definition is following
//
//	void rb_clear_constant_cache_for_id(ID id)
func RbClearConstantCacheForId(id ID) {
	C.rb_clear_constant_cache_for_id(C.ID(id))
}

// RbCloexecDup calls `rb_cloexec_dup` in C
//
// Original definition is following
//
//	int rb_cloexec_dup(int oldfd)
func RbCloexecDup(oldfd int) int {
	return int(C.rb_cloexec_dup(C.int(oldfd)))
}

// RbCloexecDup2 calls `rb_cloexec_dup2` in C
//
// Original definition is following
//
//	int rb_cloexec_dup2(int oldfd, int newfd)
func RbCloexecDup2(oldfd int, newfd int) int {
	return int(C.rb_cloexec_dup2(C.int(oldfd), C.int(newfd)))
}

// RbCloexecFcntlDupfd calls `rb_cloexec_fcntl_dupfd` in C
//
// Original definition is following
//
//	int rb_cloexec_fcntl_dupfd(int fd, int minfd)
func RbCloexecFcntlDupfd(fd int, minfd int) int {
	return int(C.rb_cloexec_fcntl_dupfd(C.int(fd), C.int(minfd)))
}

// RbCloexecOpen calls `rb_cloexec_open` in C
//
// Original definition is following
//
//	int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
func RbCloexecOpen(pathname string, flags int, mode ModeT) int {
	char, clean := string2Char(pathname)
	defer clean()

	return int(C.rb_cloexec_open(char, C.int(flags), C.mode_t(mode)))
}

// RbCloexecPipe calls `rb_cloexec_pipe` in C
//
// Original definition is following
//
//	int rb_cloexec_pipe(int fildes[2])
func RbCloexecPipe(fildes []int) int {
	return int(C.rb_cloexec_pipe(toCArray[int, C.int](fildes)))
}

// RbCloseBeforeExec calls `rb_close_before_exec` in C
//
// Original definition is following
//
//	void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds)
func RbCloseBeforeExec(lowfd int, maxhint int, noclose_fds VALUE) {
	C.rb_close_before_exec(C.int(lowfd), C.int(maxhint), C.VALUE(noclose_fds))
}

// RbCmperr calls `rb_cmperr` in C
//
// Original definition is following
//
//	void rb_cmperr(VALUE a, VALUE b)
func RbCmperr(a VALUE, b VALUE) {
	C.rb_cmperr(C.VALUE(a), C.VALUE(b))
}

// RbCmpint calls `rb_cmpint` in C
//
// Original definition is following
//
//	int rb_cmpint(VALUE val, VALUE a, VALUE b)
func RbCmpint(val VALUE, a VALUE, b VALUE) int {
	return int(C.rb_cmpint(C.VALUE(val), C.VALUE(a), C.VALUE(b)))
}

// RbComplexAbs calls `rb_complex_abs` in C
//
// Original definition is following
//
//	VALUE rb_complex_abs(VALUE z)
func RbComplexAbs(z VALUE) VALUE {
	return VALUE(C.rb_complex_abs(C.VALUE(z)))
}

// RbComplexArg calls `rb_complex_arg` in C
//
// Original definition is following
//
//	VALUE rb_complex_arg(VALUE z)
func RbComplexArg(z VALUE) VALUE {
	return VALUE(C.rb_complex_arg(C.VALUE(z)))
}

// RbComplexConjugate calls `rb_complex_conjugate` in C
//
// Original definition is following
//
//	VALUE rb_complex_conjugate(VALUE z)
func RbComplexConjugate(z VALUE) VALUE {
	return VALUE(C.rb_complex_conjugate(C.VALUE(z)))
}

// RbComplexDiv calls `rb_complex_div` in C
//
// Original definition is following
//
//	VALUE rb_complex_div(VALUE x, VALUE y)
func RbComplexDiv(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_complex_div(C.VALUE(x), C.VALUE(y)))
}

// RbComplexImag calls `rb_complex_imag` in C
//
// Original definition is following
//
//	VALUE rb_complex_imag(VALUE z)
func RbComplexImag(z VALUE) VALUE {
	return VALUE(C.rb_complex_imag(C.VALUE(z)))
}

// RbComplexMinus calls `rb_complex_minus` in C
//
// Original definition is following
//
//	VALUE rb_complex_minus(VALUE x, VALUE y)
func RbComplexMinus(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_complex_minus(C.VALUE(x), C.VALUE(y)))
}

// RbComplexMul calls `rb_complex_mul` in C
//
// Original definition is following
//
//	VALUE rb_complex_mul(VALUE x, VALUE y)
func RbComplexMul(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_complex_mul(C.VALUE(x), C.VALUE(y)))
}

// RbComplexNew calls `rb_complex_new` in C
//
// Original definition is following
//
//	VALUE rb_complex_new(VALUE real, VALUE imag)
func RbComplexNew(real VALUE, imag VALUE) VALUE {
	return VALUE(C.rb_complex_new(C.VALUE(real), C.VALUE(imag)))
}

// RbComplexNewPolar calls `rb_complex_new_polar` in C
//
// Original definition is following
//
//	VALUE rb_complex_new_polar(VALUE abs, VALUE arg)
func RbComplexNewPolar(abs VALUE, arg VALUE) VALUE {
	return VALUE(C.rb_complex_new_polar(C.VALUE(abs), C.VALUE(arg)))
}

// RbComplexPlus calls `rb_complex_plus` in C
//
// Original definition is following
//
//	VALUE rb_complex_plus(VALUE x, VALUE y)
func RbComplexPlus(x VALUE, y VALUE) VALUE {
	return VALUE(C.rb_complex_plus(C.VALUE(x), C.VALUE(y)))
}

// RbComplexPow calls `rb_complex_pow` in C
//
// Original definition is following
//
//	VALUE rb_complex_pow(VALUE base, VALUE exp)
func RbComplexPow(base VALUE, exp VALUE) VALUE {
	return VALUE(C.rb_complex_pow(C.VALUE(base), C.VALUE(exp)))
}

// RbComplexRaw calls `rb_complex_raw` in C
//
// Original definition is following
//
//	VALUE rb_complex_raw(VALUE real, VALUE imag)
func RbComplexRaw(real VALUE, imag VALUE) VALUE {
	return VALUE(C.rb_complex_raw(C.VALUE(real), C.VALUE(imag)))
}

// RbComplexReal calls `rb_complex_real` in C
//
// Original definition is following
//
//	VALUE rb_complex_real(VALUE z)
func RbComplexReal(z VALUE) VALUE {
	return VALUE(C.rb_complex_real(C.VALUE(z)))
}

// RbComplexUminus calls `rb_complex_uminus` in C
//
// Original definition is following
//
//	VALUE rb_complex_uminus(VALUE z)
func RbComplexUminus(z VALUE) VALUE {
	return VALUE(C.rb_complex_uminus(C.VALUE(z)))
}

// RbConstDefined calls `rb_const_defined` in C
//
// Original definition is following
//
//	int rb_const_defined(VALUE space, ID name)
func RbConstDefined(space VALUE, name ID) int {
	return int(C.rb_const_defined(C.VALUE(space), C.ID(name)))
}

// RbConstDefinedAt calls `rb_const_defined_at` in C
//
// Original definition is following
//
//	int rb_const_defined_at(VALUE space, ID name)
func RbConstDefinedAt(space VALUE, name ID) int {
	return int(C.rb_const_defined_at(C.VALUE(space), C.ID(name)))
}

// RbConstDefinedFrom calls `rb_const_defined_from` in C
//
// Original definition is following
//
//	int rb_const_defined_from(VALUE space, ID name)
func RbConstDefinedFrom(space VALUE, name ID) int {
	return int(C.rb_const_defined_from(C.VALUE(space), C.ID(name)))
}

// RbConstGet calls `rb_const_get` in C
//
// Original definition is following
//
//	VALUE rb_const_get(VALUE space, ID name)
func RbConstGet(space VALUE, name ID) VALUE {
	return VALUE(C.rb_const_get(C.VALUE(space), C.ID(name)))
}

// RbConstGetAt calls `rb_const_get_at` in C
//
// Original definition is following
//
//	VALUE rb_const_get_at(VALUE space, ID name)
func RbConstGetAt(space VALUE, name ID) VALUE {
	return VALUE(C.rb_const_get_at(C.VALUE(space), C.ID(name)))
}

// RbConstGetFrom calls `rb_const_get_from` in C
//
// Original definition is following
//
//	VALUE rb_const_get_from(VALUE space, ID name)
func RbConstGetFrom(space VALUE, name ID) VALUE {
	return VALUE(C.rb_const_get_from(C.VALUE(space), C.ID(name)))
}

// RbConstList calls `rb_const_list` in C
//
// Original definition is following
//
//	VALUE rb_const_list(void*)
func RbConstList(arg1 unsafe.Pointer) VALUE {
	return VALUE(C.rb_const_list(arg1))
}

// RbConstRemove calls `rb_const_remove` in C
//
// Original definition is following
//
//	VALUE rb_const_remove(VALUE space, ID name)
func RbConstRemove(space VALUE, name ID) VALUE {
	return VALUE(C.rb_const_remove(C.VALUE(space), C.ID(name)))
}

// RbConstSet calls `rb_const_set` in C
//
// Original definition is following
//
//	void rb_const_set(VALUE space, ID name, VALUE val)
func RbConstSet(space VALUE, name ID, val VALUE) {
	C.rb_const_set(C.VALUE(space), C.ID(name), C.VALUE(val))
}

// RbConvertType calls `rb_convert_type` in C
//
// Original definition is following
//
//	VALUE rb_convert_type(VALUE val, int type, const char *name, const char *mid)
func RbConvertType(val VALUE, t int, name string, mid string) VALUE {
	charName, cleanCharname := string2Char(name)
	defer cleanCharname()

	charMid, cleanCharmid := string2Char(mid)
	defer cleanCharmid()

	return VALUE(C.rb_convert_type(C.VALUE(val), C.int(t), charName, charMid))
}

// RbCopyGenericIvar calls `rb_copy_generic_ivar` in C
//
// Original definition is following
//
//	void rb_copy_generic_ivar(VALUE clone, VALUE obj)
func RbCopyGenericIvar(clone VALUE, obj VALUE) {
	C.rb_copy_generic_ivar(C.VALUE(clone), C.VALUE(obj))
}

// RbCstr2Inum calls `rb_cstr2inum` in C
//
// Original definition is following
//
//	VALUE rb_cstr2inum(const char *str, int base)
func RbCstr2Inum(str string, base int) VALUE {
	char, clean := string2Char(str)
	defer clean()

	return VALUE(C.rb_cstr2inum(char, C.int(base)))
}

// RbCstrToDbl calls `rb_cstr_to_dbl` in C
//
// Original definition is following
//
//	double rb_cstr_to_dbl(const char *str, int mode)
func RbCstrToDbl(str string, mode int) Double {
	char, clean := string2Char(str)
	defer clean()

	return Double(C.rb_cstr_to_dbl(char, C.int(mode)))
}

// RbCstrToInum calls `rb_cstr_to_inum` in C
//
// Original definition is following
//
//	VALUE rb_cstr_to_inum(const char *str, int base, int badcheck)
func RbCstrToInum(str string, base int, badcheck int) VALUE {
	char, clean := string2Char(str)
	defer clean()

	return VALUE(C.rb_cstr_to_inum(char, C.int(base), C.int(badcheck)))
}

// RbCurrentReceiver calls `rb_current_receiver` in C
//
// Original definition is following
//
//	VALUE rb_current_receiver(void)
func RbCurrentReceiver() VALUE {
	return VALUE(C.rb_current_receiver())
}

// RbCvGet calls `rb_cv_get` in C
//
// Original definition is following
//
//	VALUE rb_cv_get(VALUE klass, const char *name)
func RbCvGet(klass VALUE, name string) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_cv_get(C.VALUE(klass), char))
}

// RbCvSet calls `rb_cv_set` in C
//
// Original definition is following
//
//	void rb_cv_set(VALUE klass, const char *name, VALUE val)
func RbCvSet(klass VALUE, name string, val VALUE) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_cv_set(C.VALUE(klass), char, C.VALUE(val))
}

// RbCvarDefined calls `rb_cvar_defined` in C
//
// Original definition is following
//
//	VALUE rb_cvar_defined(VALUE klass, ID name)
func RbCvarDefined(klass VALUE, name ID) VALUE {
	return VALUE(C.rb_cvar_defined(C.VALUE(klass), C.ID(name)))
}

// RbCvarFind calls `rb_cvar_find` in C
//
// Original definition is following
//
//	VALUE rb_cvar_find(VALUE klass, ID name, VALUE *front)
func RbCvarFind(klass VALUE, name ID, front *VALUE) VALUE {
	var cFront C.VALUE
	ret := VALUE(C.rb_cvar_find(C.VALUE(klass), C.ID(name), &cFront))
	*front = VALUE(cFront)
	return ret
}

// RbCvarGet calls `rb_cvar_get` in C
//
// Original definition is following
//
//	VALUE rb_cvar_get(VALUE klass, ID name)
func RbCvarGet(klass VALUE, name ID) VALUE {
	return VALUE(C.rb_cvar_get(C.VALUE(klass), C.ID(name)))
}

// RbCvarSet calls `rb_cvar_set` in C
//
// Original definition is following
//
//	void rb_cvar_set(VALUE klass, ID name, VALUE val)
func RbCvarSet(klass VALUE, name ID, val VALUE) {
	C.rb_cvar_set(C.VALUE(klass), C.ID(name), C.VALUE(val))
}

// RbDataObjectGet calls `rb_data_object_get` in C
//
// Original definition is following
//
//	rb_data_object_get(VALUE obj)
func RbDataObjectGet(obj VALUE) unsafe.Pointer {
	return unsafe.Pointer(C.rb_data_object_get(C.VALUE(obj)))
}

// RbDataObjectMake calls `rb_data_object_make` in C
//
// Original definition is following
//
//	rb_data_object_make(VALUE klass, RUBY_DATA_FUNC mark_func, RUBY_DATA_FUNC free_func, void **data/;"
func RbDataObjectMake(klass VALUE, mark_func unsafe.Pointer, free_func unsafe.Pointer, datap *unsafe.Pointer, size SizeT) VALUE {
	return VALUE(C.rb_data_object_make(C.VALUE(klass), toCFunctionPointer(mark_func), toCFunctionPointer(free_func), datap, C.size_t(size)))
}

// RbDataObjectWrap calls `rb_data_object_wrap` in C
//
// Original definition is following
//
//	VALUE rb_data_object_wrap(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
func RbDataObjectWrap(klass VALUE, datap unsafe.Pointer, dmark unsafe.Pointer, dfree unsafe.Pointer) VALUE {
	return VALUE(C.rb_data_object_wrap(C.VALUE(klass), datap, toCFunctionPointer(dmark), toCFunctionPointer(dfree)))
}

// RbDataObjectZalloc calls `rb_data_object_zalloc` in C
//
// Original definition is following
//
//	VALUE rb_data_object_zalloc(VALUE klass, size_t size, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
func RbDataObjectZalloc(klass VALUE, size SizeT, dmark unsafe.Pointer, dfree unsafe.Pointer) VALUE {
	return VALUE(C.rb_data_object_zalloc(C.VALUE(klass), C.size_t(size), toCFunctionPointer(dmark), toCFunctionPointer(dfree)))
}

// RbDataTypedObjectMake calls `rb_data_typed_object_make` in C
//
// Original definition is following
//
//	rb_data_typed_object_make(VALUE klass, const rb_data_type_t *type, void **datap, size_t size)
func RbDataTypedObjectMake(klass VALUE, t *RbDataTypeT, datap *unsafe.Pointer, size SizeT) VALUE {
	var cT C.rb_data_type_t
	ret := VALUE(C.rb_data_typed_object_make(C.VALUE(klass), &cT, datap, C.size_t(size)))
	*t = RbDataTypeT(cT)
	return ret
}

// RbDataTypedObjectWrap calls `rb_data_typed_object_wrap` in C
//
// Original definition is following
//
//	VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type)
func RbDataTypedObjectWrap(klass VALUE, datap unsafe.Pointer, t *RbDataTypeT) VALUE {
	var cT C.rb_data_type_t
	ret := VALUE(C.rb_data_typed_object_wrap(C.VALUE(klass), datap, &cT))
	*t = RbDataTypeT(cT)
	return ret
}

// RbDataTypedObjectZalloc calls `rb_data_typed_object_zalloc` in C
//
// Original definition is following
//
//	VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type)
func RbDataTypedObjectZalloc(klass VALUE, size SizeT, t *RbDataTypeT) VALUE {
	var cT C.rb_data_type_t
	ret := VALUE(C.rb_data_typed_object_zalloc(C.VALUE(klass), C.size_t(size), &cT))
	*t = RbDataTypeT(cT)
	return ret
}

// RbDbl2Big calls `rb_dbl2big` in C
//
// Original definition is following
//
//	VALUE rb_dbl2big(double d)
func RbDbl2Big(d Double) VALUE {
	return VALUE(C.rb_dbl2big(C.double(d)))
}

// RbDblCmp calls `rb_dbl_cmp` in C
//
// Original definition is following
//
//	VALUE rb_dbl_cmp(double lhs, double rhs)
func RbDblCmp(lhs Double, rhs Double) VALUE {
	return VALUE(C.rb_dbl_cmp(C.double(lhs), C.double(rhs)))
}

// RbDblComplexNew calls `rb_dbl_complex_new` in C
//
// Original definition is following
//
//	VALUE rb_dbl_complex_new(double real, double imag)
func RbDblComplexNew(real Double, imag Double) VALUE {
	return VALUE(C.rb_dbl_complex_new(C.double(real), C.double(imag)))
}

// RbDebugRstringNullPtr calls `rb_debug_rstring_null_ptr` in C
//
// Original definition is following
//
//	void rb_debug_rstring_null_ptr(const char *func)
func RbDebugRstringNullPtr(fun string) {
	char, clean := string2Char(fun)
	defer clean()

	C.rb_debug_rstring_null_ptr(char)
}

// RbDefineAlias calls `rb_define_alias` in C
//
// Original definition is following
//
//	void rb_define_alias(VALUE klass, const char *dst, const char *src)
func RbDefineAlias(klass VALUE, dst string, src string) {
	charDst, cleanChardst := string2Char(dst)
	defer cleanChardst()

	charSrc, cleanCharsrc := string2Char(src)
	defer cleanCharsrc()

	C.rb_define_alias(C.VALUE(klass), charDst, charSrc)
}

// RbDefineAllocFunc calls `rb_define_alloc_func` in C
//
// Original definition is following
//
//	void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
func RbDefineAllocFunc(klass VALUE, fun unsafe.Pointer) {
	C.rb_define_alloc_func(C.VALUE(klass), C.rb_alloc_func_t(fun))
}

// RbDefineAttr calls `rb_define_attr` in C
//
// Original definition is following
//
//	void rb_define_attr(VALUE klass, const char *name, int read, int write)
func RbDefineAttr(klass VALUE, name string, read int, write int) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_define_attr(C.VALUE(klass), char, C.int(read), C.int(write))
}

// RbDefineClass calls `rb_define_class` in C
//
// Original definition is following
//
//	VALUE rb_define_class(const char *name, VALUE super)
func RbDefineClass(name string, super VALUE) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_define_class(char, C.VALUE(super)))
}

// RbDefineClassId calls `rb_define_class_id` in C
//
// Original definition is following
//
//	VALUE rb_define_class_id(ID id, VALUE super)
func RbDefineClassId(id ID, super VALUE) VALUE {
	return VALUE(C.rb_define_class_id(C.ID(id), C.VALUE(super)))
}

// RbDefineClassIdUnder calls `rb_define_class_id_under` in C
//
// Original definition is following
//
//	VALUE rb_define_class_id_under(VALUE outer, ID id, VALUE super)
func RbDefineClassIdUnder(outer VALUE, id ID, super VALUE) VALUE {
	return VALUE(C.rb_define_class_id_under(C.VALUE(outer), C.ID(id), C.VALUE(super)))
}

// RbDefineClassUnder calls `rb_define_class_under` in C
//
// Original definition is following
//
//	VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
func RbDefineClassUnder(outer VALUE, name string, super VALUE) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_define_class_under(C.VALUE(outer), char, C.VALUE(super)))
}

// RbDefineClassVariable calls `rb_define_class_variable` in C
//
// Original definition is following
//
//	void rb_define_class_variable(VALUE, const char*, VALUE)
func RbDefineClassVariable(arg1 VALUE, arg2 string, arg3 VALUE) {
	char, clean := string2Char(arg2)
	defer clean()

	C.rb_define_class_variable(C.VALUE(arg1), char, C.VALUE(arg3))
}

// RbDefineConst calls `rb_define_const` in C
//
// Original definition is following
//
//	void rb_define_const(VALUE klass, const char *name, VALUE val)
func RbDefineConst(klass VALUE, name string, val VALUE) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_define_const(C.VALUE(klass), char, C.VALUE(val))
}

// RbDefineFinalizer calls `rb_define_finalizer` in C
//
// Original definition is following
//
//	VALUE rb_define_finalizer(VALUE obj, VALUE block)
func RbDefineFinalizer(obj VALUE, block VALUE) VALUE {
	return VALUE(C.rb_define_finalizer(C.VALUE(obj), C.VALUE(block)))
}

// RbDefineGlobalConst calls `rb_define_global_const` in C
//
// Original definition is following
//
//	void rb_define_global_const(const char *name, VALUE val)
func RbDefineGlobalConst(name string, val VALUE) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_define_global_const(char, C.VALUE(val))
}

// RbDefineGlobalFunction calls `rb_define_global_function` in C
//
// Original definition is following
//
//	void rb_define_global_function(const char *mid, VALUE (*func)(), int arity)
func RbDefineGlobalFunction(mid string, arg2 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_global_function(char, toCFunctionPointer(arg2), C.int(arity))
}

// RbDefineHookedVariable calls `rb_define_hooked_variable` in C
//
// Original definition is following
//
//	void rb_define_hooked_variable(const char *name, VALUE *var, rb_gvar_getter_t *getter, rb_gvar_setter_t *setter)
func RbDefineHookedVariable(name string, v *VALUE, getter *RbGvarGetterT, setter *RbGvarSetterT) {
	char, clean := string2Char(name)
	defer clean()

	var cV C.VALUE
	var cGetter C.rb_gvar_getter_t
	var cSetter C.rb_gvar_setter_t
	C.rb_define_hooked_variable(char, &cV, &cGetter, &cSetter)
	*v = VALUE(cV)
	*getter = RbGvarGetterT(cGetter)
	*setter = RbGvarSetterT(cSetter)
}

// RbDefineMethod calls `rb_define_method` in C
//
// Original definition is following
//
//	void rb_define_method(VALUE klass, const char *mid, VALUE (*func)(), int arity)
func RbDefineMethod(klass VALUE, mid string, arg3 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_method(C.VALUE(klass), char, toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineMethodId calls `rb_define_method_id` in C
//
// Original definition is following
//
//	void rb_define_method_id(VALUE klass, ID mid, VALUE (*func)(), int arity)
func RbDefineMethodId(klass VALUE, mid ID, arg3 unsafe.Pointer, arity int) {
	C.rb_define_method_id(C.VALUE(klass), C.ID(mid), toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineModule calls `rb_define_module` in C
//
// Original definition is following
//
//	VALUE rb_define_module(const char *name)
func RbDefineModule(name string) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_define_module(char))
}

// RbDefineModuleFunction calls `rb_define_module_function` in C
//
// Original definition is following
//
//	void rb_define_module_function(VALUE klass, const char *mid, VALUE (*func)(), int arity)
func RbDefineModuleFunction(klass VALUE, mid string, arg3 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_module_function(C.VALUE(klass), char, toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineModuleId calls `rb_define_module_id` in C
//
// Original definition is following
//
//	VALUE rb_define_module_id(ID id)
func RbDefineModuleId(id ID) VALUE {
	return VALUE(C.rb_define_module_id(C.ID(id)))
}

// RbDefineModuleIdUnder calls `rb_define_module_id_under` in C
//
// Original definition is following
//
//	VALUE rb_define_module_id_under(VALUE outer, ID id)
func RbDefineModuleIdUnder(outer VALUE, id ID) VALUE {
	return VALUE(C.rb_define_module_id_under(C.VALUE(outer), C.ID(id)))
}

// RbDefineModuleUnder calls `rb_define_module_under` in C
//
// Original definition is following
//
//	VALUE rb_define_module_under(VALUE outer, const char *name)
func RbDefineModuleUnder(outer VALUE, name string) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_define_module_under(C.VALUE(outer), char))
}

// RbDefinePrivateMethod calls `rb_define_private_method` in C
//
// Original definition is following
//
//	void rb_define_private_method(VALUE klass, const char *mid, VALUE (*func)(), int arity)
func RbDefinePrivateMethod(klass VALUE, mid string, arg3 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_private_method(C.VALUE(klass), char, toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineProtectedMethod calls `rb_define_protected_method` in C
//
// Original definition is following
//
//	void rb_define_protected_method(VALUE klass, const char *mid, VALUE (*func)(), int arity)
func RbDefineProtectedMethod(klass VALUE, mid string, arg3 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_protected_method(C.VALUE(klass), char, toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineReadonlyVariable calls `rb_define_readonly_variable` in C
//
// Original definition is following
//
//	void rb_define_readonly_variable(const char *name, const VALUE *var)
func RbDefineReadonlyVariable(name string, v *VALUE) {
	char, clean := string2Char(name)
	defer clean()

	var cV C.VALUE
	C.rb_define_readonly_variable(char, &cV)
	*v = VALUE(cV)
}

// RbDefineSingletonMethod calls `rb_define_singleton_method` in C
//
// Original definition is following
//
//	void rb_define_singleton_method(VALUE obj, const char *mid, VALUE(*func)(), int arity)
func RbDefineSingletonMethod(obj VALUE, mid string, arg3 unsafe.Pointer, arity int) {
	char, clean := string2Char(mid)
	defer clean()

	C.rb_define_singleton_method(C.VALUE(obj), char, toCFunctionPointer(arg3), C.int(arity))
}

// RbDefineVariable calls `rb_define_variable` in C
//
// Original definition is following
//
//	void rb_define_variable(const char *name, VALUE *var)
func RbDefineVariable(name string, v *VALUE) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_define_variable(char, (*C.VALUE)(v))
}

// RbDefineVirtualVariable calls `rb_define_virtual_variable` in C
//
// Original definition is following
//
//	void rb_define_virtual_variable(const char *name, rb_gvar_getter_t *getter, rb_gvar_setter_t *setter)
func RbDefineVirtualVariable(name string, getter *RbGvarGetterT, setter *RbGvarSetterT) {
	char, clean := string2Char(name)
	defer clean()

	var cGetter C.rb_gvar_getter_t
	var cSetter C.rb_gvar_setter_t
	C.rb_define_virtual_variable(char, &cGetter, &cSetter)
	*getter = RbGvarGetterT(cGetter)
	*setter = RbGvarSetterT(cSetter)
}

// RbDeprecateConstant calls `rb_deprecate_constant` in C
//
// Original definition is following
//
//	void rb_deprecate_constant(VALUE mod, const char *name)
func RbDeprecateConstant(mod VALUE, name string) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_deprecate_constant(C.VALUE(mod), char)
}

// RbDetachProcess calls `rb_detach_process` in C
//
// Original definition is following
//
//	VALUE rb_detach_process(pid_t pid)
func RbDetachProcess(pid PidT) VALUE {
	return VALUE(C.rb_detach_process(C.pid_t(pid)))
}

// RbDirGetwd calls `rb_dir_getwd` in C
//
// Original definition is following
//
//	VALUE rb_dir_getwd(void)
func RbDirGetwd() VALUE {
	return VALUE(C.rb_dir_getwd())
}

// RbDuringGc calls `rb_during_gc` in C
//
// Original definition is following
//
//	int rb_during_gc(void)
func RbDuringGc() int {
	return int(C.rb_during_gc())
}

// RbEach calls `rb_each` in C
//
// Original definition is following
//
//	VALUE rb_each(VALUE obj)
func RbEach(obj VALUE) VALUE {
	return VALUE(C.rb_each(C.VALUE(obj)))
}

// RbEnsure calls `rb_ensure` in C
//
// Original definition is following
//
//	VALUE rb_ensure(VALUE (*b_proc)(VALUE), VALUE data1, VALUE (*e_proc)(VALUE), VALUE data2)
func RbEnsure(arg1 unsafe.Pointer, data1 VALUE, arg3 unsafe.Pointer, data2 VALUE) VALUE {
	return VALUE(C.rb_ensure(toCFunctionPointer(arg1), C.VALUE(data1), toCFunctionPointer(arg3), C.VALUE(data2)))
}

// RbEnumValuesPack calls `rb_enum_values_pack` in C
//
// Original definition is following
//
//	VALUE rb_enum_values_pack(int argc, const VALUE *argv)
func RbEnumValuesPack(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_enum_values_pack(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbEnumeratorize calls `rb_enumeratorize` in C
//
// Original definition is following
//
//	VALUE rb_enumeratorize(VALUE recv, VALUE meth, int argc, const VALUE *argv)
func RbEnumeratorize(recv VALUE, meth VALUE, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_enumeratorize(C.VALUE(recv), C.VALUE(meth), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbEnumeratorizeWithSize calls `rb_enumeratorize_with_size` in C
//
// Original definition is following
//
//	VALUE rb_enumeratorize_with_size(VALUE recv, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *func)
func RbEnumeratorizeWithSize(recv VALUE, meth VALUE, argc int, argv *VALUE, fun *RbEnumeratorSizeFunc) VALUE {
	var cArgv C.VALUE
	var cFun C.rb_enumerator_size_func
	ret := VALUE(C.rb_enumeratorize_with_size(C.VALUE(recv), C.VALUE(meth), C.int(argc), &cArgv, &cFun))
	*argv = VALUE(cArgv)
	*fun = RbEnumeratorSizeFunc(cFun)
	return ret
}

// RbEnumeratorizeWithSizeKw calls `rb_enumeratorize_with_size_kw` in C
//
// Original definition is following
//
//	VALUE rb_enumeratorize_with_size_kw(VALUE recv, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *func, int kw_splat)
func RbEnumeratorizeWithSizeKw(recv VALUE, meth VALUE, argc int, argv *VALUE, fun *RbEnumeratorSizeFunc, kw_splat int) VALUE {
	var cArgv C.VALUE
	var cFun C.rb_enumerator_size_func
	ret := VALUE(C.rb_enumeratorize_with_size_kw(C.VALUE(recv), C.VALUE(meth), C.int(argc), &cArgv, &cFun, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	*fun = RbEnumeratorSizeFunc(cFun)
	return ret
}

// RbEnvClear calls `rb_env_clear` in C
//
// Original definition is following
//
//	VALUE rb_env_clear(void)
func RbEnvClear() VALUE {
	return VALUE(C.rb_env_clear())
}

// RbEql calls `rb_eql` in C
//
// Original definition is following
//
//	int rb_eql(VALUE lhs, VALUE rhs)
func RbEql(lhs VALUE, rhs VALUE) int {
	return int(C.rb_eql(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbEqual calls `rb_equal` in C
//
// Original definition is following
//
//	VALUE rb_equal(VALUE lhs, VALUE rhs)
func RbEqual(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_equal(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbErrinfo calls `rb_errinfo` in C
//
// Original definition is following
//
//	VALUE rb_errinfo(void)
func RbErrinfo() VALUE {
	return VALUE(C.rb_errinfo())
}

// RbErrno calls `rb_errno` in C
//
// Original definition is following
//
//	int rb_errno(void)
func RbErrno() int {
	return int(C.rb_errno())
}

// RbErrnoPtr calls `rb_errno_ptr` in C
//
// Original definition is following
//
//	int *rb_errno_ptr(void)
func RbErrnoPtr() *Int {
	return (*Int)(C.rb_errno_ptr())
}

// RbErrnoSet calls `rb_errno_set` in C
//
// Original definition is following
//
//	void rb_errno_set(int err)
func RbErrnoSet(err int) {
	C.rb_errno_set(C.int(err))
}

// RbErrorArity calls `rb_error_arity` in C
//
// Original definition is following
//
//	void rb_error_arity(int argc, int min, int max)
func RbErrorArity(argc int, min int, max int) {
	C.rb_error_arity(C.int(argc), C.int(min), C.int(max))
}

// RbErrorFrozen calls `rb_error_frozen` in C
//
// Original definition is following
//
//	void rb_error_frozen(const char *what)
func RbErrorFrozen(what string) {
	char, clean := string2Char(what)
	defer clean()

	C.rb_error_frozen(char)
}

// RbErrorFrozenObject calls `rb_error_frozen_object` in C
//
// Original definition is following
//
//	void rb_error_frozen_object(VALUE what)
func RbErrorFrozenObject(what VALUE) {
	C.rb_error_frozen_object(C.VALUE(what))
}

// RbEvalCmdKw calls `rb_eval_cmd_kw` in C
//
// Original definition is following
//
//	VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
func RbEvalCmdKw(cmd VALUE, arg VALUE, kw_splat int) VALUE {
	return VALUE(C.rb_eval_cmd_kw(C.VALUE(cmd), C.VALUE(arg), C.int(kw_splat)))
}

// RbEvalString calls `rb_eval_string` in C
//
// Original definition is following
//
//	VALUE rb_eval_string(const char *str)
func RbEvalString(str string) VALUE {
	char, clean := string2Char(str)
	defer clean()

	return VALUE(C.rb_eval_string(char))
}

// RbEvalStringProtect calls `rb_eval_string_protect` in C
//
// Original definition is following
//
//	VALUE rb_eval_string_protect(const char *str, int *state)
func RbEvalStringProtect(str string, state *int) VALUE {
	char, clean := string2Char(str)
	defer clean()

	var cState C.int
	ret := VALUE(C.rb_eval_string_protect(char, &cState))
	*state = int(cState)
	return ret
}

// RbEvalStringWrap calls `rb_eval_string_wrap` in C
//
// Original definition is following
//
//	VALUE rb_eval_string_wrap(const char *str, int *state)
func RbEvalStringWrap(str string, state *int) VALUE {
	char, clean := string2Char(str)
	defer clean()

	var cState C.int
	ret := VALUE(C.rb_eval_string_wrap(char, &cState))
	*state = int(cState)
	return ret
}

// RbExcFatal calls `rb_exc_fatal` in C
//
// Original definition is following
//
//	void rb_exc_fatal(VALUE exc)
func RbExcFatal(exc VALUE) {
	C.rb_exc_fatal(C.VALUE(exc))
}

// RbExcNew calls `rb_exc_new` in C
//
// Original definition is following
//
//	VALUE rb_exc_new(VALUE etype, const char *ptr, long len)
func RbExcNew(etype VALUE, ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_exc_new(C.VALUE(etype), char, C.long(len)))
}

// RbExcNewCstr calls `rb_exc_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_exc_new_cstr(VALUE etype, const char *str)
func RbExcNewCstr(etype VALUE, str string) VALUE {
	char, clean := string2Char(str)
	defer clean()

	return VALUE(C.rb_exc_new_cstr(C.VALUE(etype), char))
}

// RbExcNewStr calls `rb_exc_new_str` in C
//
// Original definition is following
//
//	VALUE rb_exc_new_str(VALUE etype, VALUE str)
func RbExcNewStr(etype VALUE, str VALUE) VALUE {
	return VALUE(C.rb_exc_new_str(C.VALUE(etype), C.VALUE(str)))
}

// RbExcRaise calls `rb_exc_raise` in C
//
// Original definition is following
//
//	void rb_exc_raise(VALUE exc)
func RbExcRaise(exc VALUE) {
	C.rb_exc_raise(C.VALUE(exc))
}

// RbExecRecursive calls `rb_exec_recursive` in C
//
// Original definition is following
//
//	VALUE rb_exec_recursive(VALUE (*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
func RbExecRecursive(arg1 unsafe.Pointer, g VALUE, h VALUE) VALUE {
	return VALUE(C.rb_exec_recursive(toCFunctionPointer(arg1), C.VALUE(g), C.VALUE(h)))
}

// RbExecRecursiveOuter calls `rb_exec_recursive_outer` in C
//
// Original definition is following
//
//	VALUE rb_exec_recursive_outer(VALUE (*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
func RbExecRecursiveOuter(arg1 unsafe.Pointer, g VALUE, h VALUE) VALUE {
	return VALUE(C.rb_exec_recursive_outer(toCFunctionPointer(arg1), C.VALUE(g), C.VALUE(h)))
}

// RbExecRecursivePaired calls `rb_exec_recursive_paired` in C
//
// Original definition is following
//
//	VALUE rb_exec_recursive_paired(VALUE (*f)(VALUE g, VALUE h, int r), VALUE g, VALUE p, VALUE h)
func RbExecRecursivePaired(arg1 unsafe.Pointer, g VALUE, p VALUE, h VALUE) VALUE {
	return VALUE(C.rb_exec_recursive_paired(toCFunctionPointer(arg1), C.VALUE(g), C.VALUE(p), C.VALUE(h)))
}

// RbExecRecursivePairedOuter calls `rb_exec_recursive_paired_outer` in C
//
// Original definition is following
//
//	VALUE rb_exec_recursive_paired_outer(VALUE (*f)(VALUE g, VALUE h, int r), VALUE g, VALUE p, VALUE h)
func RbExecRecursivePairedOuter(arg1 unsafe.Pointer, g VALUE, p VALUE, h VALUE) VALUE {
	return VALUE(C.rb_exec_recursive_paired_outer(toCFunctionPointer(arg1), C.VALUE(g), C.VALUE(p), C.VALUE(h)))
}

// RbExit calls `rb_exit` in C
//
// Original definition is following
//
//	void rb_exit(int status)
func RbExit(status int) {
	C.rb_exit(C.int(status))
}

// RbExtRactorSafe calls `rb_ext_ractor_safe` in C
//
// Original definition is following
//
//	void rb_ext_ractor_safe(_Bool flag)
func RbExtRactorSafe(flag Bool) {
	C.rb_ext_ractor_safe(C._Bool(flag))
}

// RbExtResolveSymbol calls `rb_ext_resolve_symbol` in C
//
// Original definition is following
//
//	void *rb_ext_resolve_symbol(const char *feature, const char *symbol)
func RbExtResolveSymbol(feature string, symbol string) unsafe.Pointer {
	charFeature, cleanCharfeature := string2Char(feature)
	defer cleanCharfeature()

	charSymbol, cleanCharsymbol := string2Char(symbol)
	defer cleanCharsymbol()

	return unsafe.Pointer(C.rb_ext_resolve_symbol(charFeature, charSymbol))
}

// RbExtendObject calls `rb_extend_object` in C
//
// Original definition is following
//
//	void rb_extend_object(VALUE obj, VALUE mod)
func RbExtendObject(obj VALUE, mod VALUE) {
	C.rb_extend_object(C.VALUE(obj), C.VALUE(mod))
}

// RbExternalStrNew calls `rb_external_str_new` in C
//
// Original definition is following
//
//	VALUE rb_external_str_new(const char *ptr, long len)
func RbExternalStrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_external_str_new(char, C.long(len)))
}

// RbExternalStrNewCstr calls `rb_external_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_external_str_new_cstr(const char *ptr)
func RbExternalStrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_external_str_new_cstr(char))
}

// RbExtractKeywords calls `rb_extract_keywords` in C
//
// Original definition is following
//
//	VALUE rb_extract_keywords(VALUE *orighash)
func RbExtractKeywords(orighash *VALUE) VALUE {
	var cOrighash C.VALUE
	ret := VALUE(C.rb_extract_keywords(&cOrighash))
	*orighash = VALUE(cOrighash)
	return ret
}

// RbFAbort calls `rb_f_abort` in C
//
// Original definition is following
//
//	VALUE rb_f_abort(int argc, const VALUE *argv)
func RbFAbort(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_abort(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFExec calls `rb_f_exec` in C
//
// Original definition is following
//
//	VALUE rb_f_exec(int argc, const VALUE *argv)
func RbFExec(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_exec(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFExit calls `rb_f_exit` in C
//
// Original definition is following
//
//	VALUE rb_f_exit(int argc, const VALUE *argv)
func RbFExit(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_exit(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFGlobalVariables calls `rb_f_global_variables` in C
//
// Original definition is following
//
//	VALUE rb_f_global_variables(void)
func RbFGlobalVariables() VALUE {
	return VALUE(C.rb_f_global_variables())
}

// RbFKill calls `rb_f_kill` in C
//
// Original definition is following
//
//	VALUE rb_f_kill(int argc, const VALUE *argv)
func RbFKill(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_kill(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFNotimplement calls `rb_f_notimplement` in C
//
// Original definition is following
//
//	VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
func RbFNotimplement(argc int, argv *VALUE, obj VALUE, marker VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_notimplement(C.int(argc), &cArgv, C.VALUE(obj), C.VALUE(marker)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFRequire calls `rb_f_require` in C
//
// Original definition is following
//
//	VALUE rb_f_require(VALUE self, VALUE feature)
func RbFRequire(self VALUE, feature VALUE) VALUE {
	return VALUE(C.rb_f_require(C.VALUE(self), C.VALUE(feature)))
}

// RbFSprintf calls `rb_f_sprintf` in C
//
// Original definition is following
//
//	VALUE rb_f_sprintf(int argc, const VALUE *argv)
func RbFSprintf(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_sprintf(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFTraceVar calls `rb_f_trace_var` in C
//
// Original definition is following
//
//	VALUE rb_f_trace_var(int argc, const VALUE *argv)
func RbFTraceVar(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_trace_var(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFUntraceVar calls `rb_f_untrace_var` in C
//
// Original definition is following
//
//	VALUE rb_f_untrace_var(int argc, const VALUE *argv)
func RbFUntraceVar(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_f_untrace_var(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFdClr calls `rb_fd_clr` in C
//
// Original definition is following
//
//	void rb_fd_clr(int fd, rb_fdset_t *f)
func RbFdClr(fd int, f *RbFdsetT) {
	var cF C.rb_fdset_t
	C.rb_fd_clr(C.int(fd), &cF)
	*f = RbFdsetT(cF)
}

// RbFdCopy calls `rb_fd_copy` in C
//
// Original definition is following
//
//	void rb_fd_copy(rb_fdset_t *dst, const fd_set *src, int max)
func RbFdCopy(dst *RbFdsetT, src *FdSet, max int) {
	var cDst C.rb_fdset_t
	var cSrc C.fd_set
	C.rb_fd_copy(&cDst, &cSrc, C.int(max))
	*dst = RbFdsetT(cDst)
	*src = FdSet(cSrc)
}

// RbFdDup calls `rb_fd_dup` in C
//
// Original definition is following
//
//	void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src)
func RbFdDup(dst *RbFdsetT, src *RbFdsetT) {
	var cDst C.rb_fdset_t
	var cSrc C.rb_fdset_t
	C.rb_fd_dup(&cDst, &cSrc)
	*dst = RbFdsetT(cDst)
	*src = RbFdsetT(cSrc)
}

// RbFdFixCloexec calls `rb_fd_fix_cloexec` in C
//
// Original definition is following
//
//	void rb_fd_fix_cloexec(int fd)
func RbFdFixCloexec(fd int) {
	C.rb_fd_fix_cloexec(C.int(fd))
}

// RbFdInit calls `rb_fd_init` in C
//
// Original definition is following
//
//	void rb_fd_init(rb_fdset_t *f)
func RbFdInit(f *RbFdsetT) {
	var cF C.rb_fdset_t
	C.rb_fd_init(&cF)
	*f = RbFdsetT(cF)
}

// RbFdIsset calls `rb_fd_isset` in C
//
// Original definition is following
//
//	int rb_fd_isset(int fd, const rb_fdset_t *f)
func RbFdIsset(fd int, f *RbFdsetT) int {
	var cF C.rb_fdset_t
	ret := int(C.rb_fd_isset(C.int(fd), &cF))
	*f = RbFdsetT(cF)
	return ret
}

// RbFdMax calls `rb_fd_max` in C
//
// Original definition is following
//
//	rb_fd_max(const rb_fdset_t *f)
func RbFdMax(f *RbFdsetT) int {
	var cF C.rb_fdset_t
	ret := int(C.rb_fd_max(&cF))
	*f = RbFdsetT(cF)
	return ret
}

// RbFdPtr calls `rb_fd_ptr` in C
//
// Original definition is following
//
//	rb_fd_ptr(const rb_fdset_t *f)
func RbFdPtr(f *RbFdsetT) *FdSet {
	var cF C.rb_fdset_t
	ret := (*FdSet)(C.rb_fd_ptr(&cF))
	*f = RbFdsetT(cF)
	return ret
}

// RbFdSelect calls `rb_fd_select` in C
//
// Original definition is following
//
//	int rb_fd_select(int nfds, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)
func RbFdSelect(nfds int, rfds *RbFdsetT, wfds *RbFdsetT, efds *RbFdsetT, timeout *Timeval) int {
	var cRfds C.rb_fdset_t
	var cWfds C.rb_fdset_t
	var cEfds C.rb_fdset_t
	var cTimeout C.struct_timeval
	ret := int(C.rb_fd_select(C.int(nfds), &cRfds, &cWfds, &cEfds, &cTimeout))
	*rfds = RbFdsetT(cRfds)
	*wfds = RbFdsetT(cWfds)
	*efds = RbFdsetT(cEfds)
	*timeout = Timeval(cTimeout)
	return ret
}

// RbFdSet calls `rb_fd_set` in C
//
// Original definition is following
//
//	void rb_fd_set(int fd, rb_fdset_t *f)
func RbFdSet(fd int, f *RbFdsetT) {
	var cF C.rb_fdset_t
	C.rb_fd_set(C.int(fd), &cF)
	*f = RbFdsetT(cF)
}

// RbFdTerm calls `rb_fd_term` in C
//
// Original definition is following
//
//	void rb_fd_term(rb_fdset_t *f)
func RbFdTerm(f *RbFdsetT) {
	var cF C.rb_fdset_t
	C.rb_fd_term(&cF)
	*f = RbFdsetT(cF)
}

// RbFdZero calls `rb_fd_zero` in C
//
// Original definition is following
//
//	void rb_fd_zero(rb_fdset_t *f)
func RbFdZero(f *RbFdsetT) {
	var cF C.rb_fdset_t
	C.rb_fd_zero(&cF)
	*f = RbFdsetT(cF)
}

// RbFeatureProvided calls `rb_feature_provided` in C
//
// Original definition is following
//
//	int rb_feature_provided(const char *feature, const char **loading)
func RbFeatureProvided(feature string, loading **Char) int {
	char, clean := string2Char(feature)
	defer clean()

	return int(C.rb_feature_provided(char, (**C.char)(unsafe.Pointer(loading))))
}

// RbFiberAliveP calls `rb_fiber_alive_p` in C
//
// Original definition is following
//
//	VALUE rb_fiber_alive_p(VALUE fiber)
func RbFiberAliveP(fiber VALUE) VALUE {
	return VALUE(C.rb_fiber_alive_p(C.VALUE(fiber)))
}

// RbFiberCurrent calls `rb_fiber_current` in C
//
// Original definition is following
//
//	VALUE rb_fiber_current(void)
func RbFiberCurrent() VALUE {
	return VALUE(C.rb_fiber_current())
}

// RbFiberNew calls `rb_fiber_new` in C
//
// Original definition is following
//
//	VALUE rb_fiber_new(rb_block_call_func_t func, VALUE callback_obj)
func RbFiberNew(fun RbBlockCallFuncT, callback_obj VALUE) VALUE {
	return VALUE(C.rb_fiber_new(C.rb_block_call_func_t(fun), C.VALUE(callback_obj)))
}

// RbFiberNewStorage calls `rb_fiber_new_storage` in C
//
// Original definition is following
//
//	VALUE rb_fiber_new_storage(rb_block_call_func_t func, VALUE callback_obj, VALUE storage)
func RbFiberNewStorage(fun RbBlockCallFuncT, callback_obj VALUE, storage VALUE) VALUE {
	return VALUE(C.rb_fiber_new_storage(C.rb_block_call_func_t(fun), C.VALUE(callback_obj), C.VALUE(storage)))
}

// RbFiberRaise calls `rb_fiber_raise` in C
//
// Original definition is following
//
//	VALUE rb_fiber_raise(VALUE fiber, int argc, const VALUE *argv)
func RbFiberRaise(fiber VALUE, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_raise(C.VALUE(fiber), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberResume calls `rb_fiber_resume` in C
//
// Original definition is following
//
//	VALUE rb_fiber_resume(VALUE fiber, int argc, const VALUE *argv)
func RbFiberResume(fiber VALUE, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_resume(C.VALUE(fiber), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberResumeKw calls `rb_fiber_resume_kw` in C
//
// Original definition is following
//
//	VALUE rb_fiber_resume_kw(VALUE fiber, int argc, const VALUE *argv, int kw_splat)
func RbFiberResumeKw(fiber VALUE, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_resume_kw(C.VALUE(fiber), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberTransfer calls `rb_fiber_transfer` in C
//
// Original definition is following
//
//	VALUE rb_fiber_transfer(VALUE fiber, int argc, const VALUE *argv)
func RbFiberTransfer(fiber VALUE, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_transfer(C.VALUE(fiber), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberTransferKw calls `rb_fiber_transfer_kw` in C
//
// Original definition is following
//
//	VALUE rb_fiber_transfer_kw(VALUE fiber, int argc, const VALUE *argv, int kw_splat)
func RbFiberTransferKw(fiber VALUE, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_transfer_kw(C.VALUE(fiber), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberYield calls `rb_fiber_yield` in C
//
// Original definition is following
//
//	VALUE rb_fiber_yield(int argc, const VALUE *argv)
func RbFiberYield(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_yield(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFiberYieldKw calls `rb_fiber_yield_kw` in C
//
// Original definition is following
//
//	VALUE rb_fiber_yield_kw(int argc, const VALUE *argv, int kw_splat)
func RbFiberYieldKw(argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_fiber_yield_kw(C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFileAbsolutePath calls `rb_file_absolute_path` in C
//
// Original definition is following
//
//	VALUE rb_file_absolute_path(VALUE fname, VALUE dname)
func RbFileAbsolutePath(fname VALUE, dname VALUE) VALUE {
	return VALUE(C.rb_file_absolute_path(C.VALUE(fname), C.VALUE(dname)))
}

// RbFileDirectoryP calls `rb_file_directory_p` in C
//
// Original definition is following
//
//	VALUE rb_file_directory_p(VALUE _, VALUE path)
func RbFileDirectoryP(arg VALUE, path VALUE) VALUE {
	return VALUE(C.rb_file_directory_p(C.VALUE(arg), C.VALUE(path)))
}

// RbFileDirname calls `rb_file_dirname` in C
//
// Original definition is following
//
//	VALUE rb_file_dirname(VALUE fname)
func RbFileDirname(fname VALUE) VALUE {
	return VALUE(C.rb_file_dirname(C.VALUE(fname)))
}

// RbFileExpandPath calls `rb_file_expand_path` in C
//
// Original definition is following
//
//	VALUE rb_file_expand_path(VALUE fname, VALUE dname)
func RbFileExpandPath(fname VALUE, dname VALUE) VALUE {
	return VALUE(C.rb_file_expand_path(C.VALUE(fname), C.VALUE(dname)))
}

// RbFileOpen calls `rb_file_open` in C
//
// Original definition is following
//
//	VALUE rb_file_open(const char *fname, const char *fmode)
func RbFileOpen(fname string, fmode string) VALUE {
	charFname, cleanCharfname := string2Char(fname)
	defer cleanCharfname()

	charFmode, cleanCharfmode := string2Char(fmode)
	defer cleanCharfmode()

	return VALUE(C.rb_file_open(charFname, charFmode))
}

// RbFileOpenStr calls `rb_file_open_str` in C
//
// Original definition is following
//
//	VALUE rb_file_open_str(VALUE fname, const char *fmode)
func RbFileOpenStr(fname VALUE, fmode string) VALUE {
	char, clean := string2Char(fmode)
	defer clean()

	return VALUE(C.rb_file_open_str(C.VALUE(fname), char))
}

// RbFileSAbsolutePath calls `rb_file_s_absolute_path` in C
//
// Original definition is following
//
//	VALUE rb_file_s_absolute_path(int argc, const VALUE *argv)
func RbFileSAbsolutePath(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_file_s_absolute_path(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFileSExpandPath calls `rb_file_s_expand_path` in C
//
// Original definition is following
//
//	VALUE rb_file_s_expand_path(int argc, const VALUE *argv)
func RbFileSExpandPath(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_file_s_expand_path(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFileSize calls `rb_file_size` in C
//
// Original definition is following
//
//	off_t rb_file_size(VALUE file)
func RbFileSize(file VALUE) OffT {
	return OffT(C.rb_file_size(C.VALUE(file)))
}

// RbFilesystemStrNew calls `rb_filesystem_str_new` in C
//
// Original definition is following
//
//	VALUE rb_filesystem_str_new(const char *ptr, long len)
func RbFilesystemStrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_filesystem_str_new(char, C.long(len)))
}

// RbFilesystemStrNewCstr calls `rb_filesystem_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_filesystem_str_new_cstr(const char *ptr)
func RbFilesystemStrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_filesystem_str_new_cstr(char))
}

// RbFindFile calls `rb_find_file` in C
//
// Original definition is following
//
//	VALUE rb_find_file(VALUE path)
func RbFindFile(path VALUE) VALUE {
	return VALUE(C.rb_find_file(C.VALUE(path)))
}

// RbFindFileExt calls `rb_find_file_ext` in C
//
// Original definition is following
//
//	int rb_find_file_ext(VALUE *feature, const char *const *exts)
func RbFindFileExt(feature *VALUE, exts []string) int {
	var cFeature C.VALUE
	chars, cleanChars := strings2Chars(exts)
	defer cleanChars()

	ret := int(C.rb_find_file_ext(&cFeature, chars))
	*feature = VALUE(cFeature)
	return ret
}

// RbFix2Int calls `rb_fix2int` in C
//
// Original definition is following
//
//	long rb_fix2int(VALUE num)
func RbFix2Int(num VALUE) Long {
	return Long(C.rb_fix2int(C.VALUE(num)))
}

// RbFix2Long calls `rb_fix2long` in C
//
// Original definition is following
//
//	rb_fix2long(VALUE x)
func RbFix2Long(x VALUE) Long {
	return Long(C.rb_fix2long(C.VALUE(x)))
}

// RbFix2Short calls `rb_fix2short` in C
//
// Original definition is following
//
//	short rb_fix2short(VALUE num)
func RbFix2Short(num VALUE) Short {
	return Short(C.rb_fix2short(C.VALUE(num)))
}

// RbFix2Str calls `rb_fix2str` in C
//
// Original definition is following
//
//	VALUE rb_fix2str(VALUE val, int base)
func RbFix2Str(val VALUE, base int) VALUE {
	return VALUE(C.rb_fix2str(C.VALUE(val), C.int(base)))
}

// RbFix2Uint calls `rb_fix2uint` in C
//
// Original definition is following
//
//	unsigned long rb_fix2uint(VALUE num)
func RbFix2Uint(num VALUE) uint {
	return uint(C.rb_fix2uint(C.VALUE(num)))
}

// RbFix2Ulong calls `rb_fix2ulong` in C
//
// Original definition is following
//
//	rb_fix2ulong(VALUE x)
func RbFix2Ulong(x VALUE) uint {
	return uint(C.rb_fix2ulong(C.VALUE(x)))
}

// RbFix2Ushort calls `rb_fix2ushort` in C
//
// Original definition is following
//
//	unsigned short rb_fix2ushort(VALUE num)
func RbFix2Ushort(num VALUE) Ushort {
	return Ushort(C.rb_fix2ushort(C.VALUE(num)))
}

// RbFloatNew calls `rb_float_new` in C
//
// Original definition is following
//
//	VALUE rb_float_new(double d)
func RbFloatNew(d Double) VALUE {
	return VALUE(C.rb_float_new(C.double(d)))
}

// RbFloatNewInHeap calls `rb_float_new_in_heap` in C
//
// Original definition is following
//
//	VALUE rb_float_new_in_heap(double d)
func RbFloatNewInHeap(d Double) VALUE {
	return VALUE(C.rb_float_new_in_heap(C.double(d)))
}

// RbFloatValue calls `rb_float_value` in C
//
// Original definition is following
//
//	double rb_float_value(VALUE num)
func RbFloatValue(num VALUE) Double {
	return Double(C.rb_float_value(C.VALUE(num)))
}

// RbFltRationalize calls `rb_flt_rationalize` in C
//
// Original definition is following
//
//	VALUE rb_flt_rationalize(VALUE flt)
func RbFltRationalize(flt VALUE) VALUE {
	return VALUE(C.rb_flt_rationalize(C.VALUE(flt)))
}

// RbFltRationalizeWithPrec calls `rb_flt_rationalize_with_prec` in C
//
// Original definition is following
//
//	VALUE rb_flt_rationalize_with_prec(VALUE flt, VALUE prec)
func RbFltRationalizeWithPrec(flt VALUE, prec VALUE) VALUE {
	return VALUE(C.rb_flt_rationalize_with_prec(C.VALUE(flt), C.VALUE(prec)))
}

// RbFrameCallee calls `rb_frame_callee` in C
//
// Original definition is following
//
//	ID rb_frame_callee(void)
func RbFrameCallee() ID {
	return ID(C.rb_frame_callee())
}

// RbFrameMethodIdAndClass calls `rb_frame_method_id_and_class` in C
//
// Original definition is following
//
//	int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
func RbFrameMethodIdAndClass(idp *ID, klassp *VALUE) int {
	var cIdp C.ID
	var cKlassp C.VALUE
	ret := int(C.rb_frame_method_id_and_class(&cIdp, &cKlassp))
	*idp = ID(cIdp)
	*klassp = VALUE(cKlassp)
	return ret
}

// RbFrameThisFunc calls `rb_frame_this_func` in C
//
// Original definition is following
//
//	ID rb_frame_this_func(void)
func RbFrameThisFunc() ID {
	return ID(C.rb_frame_this_func())
}

// RbFreeGenericIvar calls `rb_free_generic_ivar` in C
//
// Original definition is following
//
//	void rb_free_generic_ivar(VALUE obj)
func RbFreeGenericIvar(obj VALUE) {
	C.rb_free_generic_ivar(C.VALUE(obj))
}

// RbFreeTmpBuffer calls `rb_free_tmp_buffer` in C
//
// Original definition is following
//
//	void rb_free_tmp_buffer(volatile VALUE *store)
func RbFreeTmpBuffer(store *VALUE) {
	var cStore C.VALUE
	C.rb_free_tmp_buffer(&cStore)
	*store = VALUE(cStore)
}

// RbFreezeSingletonClass calls `rb_freeze_singleton_class` in C
//
// Original definition is following
//
//	void rb_freeze_singleton_class(VALUE klass)
func RbFreezeSingletonClass(klass VALUE) {
	C.rb_freeze_singleton_class(C.VALUE(klass))
}

// RbFuncallPassingBlock calls `rb_funcall_passing_block` in C
//
// Original definition is following
//
//	VALUE rb_funcall_passing_block(VALUE recv, ID mid, int argc, const VALUE *argv)
func RbFuncallPassingBlock(recv VALUE, mid ID, argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcall_passing_block(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbFuncallPassingBlockKw calls `rb_funcall_passing_block_kw` in C
//
// Original definition is following
//
//	VALUE rb_funcall_passing_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
func RbFuncallPassingBlockKw(recv VALUE, mid ID, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcall_passing_block_kw(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFuncallWithBlock calls `rb_funcall_with_block` in C
//
// Original definition is following
//
//	VALUE rb_funcall_with_block(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval)
func RbFuncallWithBlock(recv VALUE, mid ID, argc int, argv *VALUE, procval VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcall_with_block(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.VALUE(procval)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFuncallWithBlockKw calls `rb_funcall_with_block_kw` in C
//
// Original definition is following
//
//	VALUE rb_funcall_with_block_kw(VALUE recv, ID mid, int argc, const VALUE *argv, VALUE procval, int kw_splat)
func RbFuncallWithBlockKw(recv VALUE, mid ID, argc int, argv *VALUE, procval VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcall_with_block_kw(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.VALUE(procval), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFuncallv calls `rb_funcallv` in C
//
// Original definition is following
//
//	VALUE rb_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
func RbFuncallv(recv VALUE, mid ID, argc int, argv []VALUE) VALUE {
	return VALUE(C.rb_funcallv(C.VALUE(recv), C.ID(mid), C.int(argc), toCArray[VALUE, C.VALUE](argv)))
}

// RbFuncallvKw calls `rb_funcallv_kw` in C
//
// Original definition is following
//
//	VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
func RbFuncallvKw(recv VALUE, mid ID, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcallv_kw(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbFuncallvPublic calls `rb_funcallv_public` in C
//
// Original definition is following
//
//	VALUE rb_funcallv_public(VALUE recv, ID mid, int argc, const VALUE *argv)
func RbFuncallvPublic(recv VALUE, mid ID, argc int, argv []VALUE) VALUE {
	return VALUE(C.rb_funcallv_public(C.VALUE(recv), C.ID(mid), C.int(argc), toCArray[VALUE, C.VALUE](argv)))
}

// RbFuncallvPublicKw calls `rb_funcallv_public_kw` in C
//
// Original definition is following
//
//	VALUE rb_funcallv_public_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
func RbFuncallvPublicKw(recv VALUE, mid ID, argc int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_funcallv_public_kw(C.VALUE(recv), C.ID(mid), C.int(argc), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbGc calls `rb_gc` in C
//
// Original definition is following
//
//	void rb_gc(void)
func RbGc() {
	C.rb_gc()
}

// RbGcAdjustMemoryUsage calls `rb_gc_adjust_memory_usage` in C
//
// Original definition is following
//
//	void rb_gc_adjust_memory_usage(ssize_t diff)
func RbGcAdjustMemoryUsage(diff SsizeT) {
	C.rb_gc_adjust_memory_usage(C.ssize_t(diff))
}

// RbGcCopyFinalizer calls `rb_gc_copy_finalizer` in C
//
// Original definition is following
//
//	void rb_gc_copy_finalizer(VALUE dst, VALUE src)
func RbGcCopyFinalizer(dst VALUE, src VALUE) {
	C.rb_gc_copy_finalizer(C.VALUE(dst), C.VALUE(src))
}

// RbGcCount calls `rb_gc_count` in C
//
// Original definition is following
//
//	size_t rb_gc_count(void)
func RbGcCount() SizeT {
	return SizeT(C.rb_gc_count())
}

// RbGcDisable calls `rb_gc_disable` in C
//
// Original definition is following
//
//	VALUE rb_gc_disable(void)
func RbGcDisable() VALUE {
	return VALUE(C.rb_gc_disable())
}

// RbGcEnable calls `rb_gc_enable` in C
//
// Original definition is following
//
//	VALUE rb_gc_enable(void)
func RbGcEnable() VALUE {
	return VALUE(C.rb_gc_enable())
}

// RbGcLatestGcInfo calls `rb_gc_latest_gc_info` in C
//
// Original definition is following
//
//	VALUE rb_gc_latest_gc_info(VALUE key_or_buf)
func RbGcLatestGcInfo(key_or_buf VALUE) VALUE {
	return VALUE(C.rb_gc_latest_gc_info(C.VALUE(key_or_buf)))
}

// RbGcLocation calls `rb_gc_location` in C
//
// Original definition is following
//
//	VALUE rb_gc_location(VALUE obj)
func RbGcLocation(obj VALUE) VALUE {
	return VALUE(C.rb_gc_location(C.VALUE(obj)))
}

// RbGcMark calls `rb_gc_mark` in C
//
// Original definition is following
//
//	void rb_gc_mark(VALUE obj)
func RbGcMark(obj VALUE) {
	C.rb_gc_mark(C.VALUE(obj))
}

// RbGcMarkLocations calls `rb_gc_mark_locations` in C
//
// Original definition is following
//
//	void rb_gc_mark_locations(const VALUE *start, const VALUE *end)
func RbGcMarkLocations(start *VALUE, end *VALUE) {
	var cStart C.VALUE
	var cEnd C.VALUE
	C.rb_gc_mark_locations(&cStart, &cEnd)
	*start = VALUE(cStart)
	*end = VALUE(cEnd)
}

// RbGcMarkMaybe calls `rb_gc_mark_maybe` in C
//
// Original definition is following
//
//	void rb_gc_mark_maybe(VALUE obj)
func RbGcMarkMaybe(obj VALUE) {
	C.rb_gc_mark_maybe(C.VALUE(obj))
}

// RbGcMarkMovable calls `rb_gc_mark_movable` in C
//
// Original definition is following
//
//	void rb_gc_mark_movable(VALUE obj)
func RbGcMarkMovable(obj VALUE) {
	C.rb_gc_mark_movable(C.VALUE(obj))
}

// RbGcRegisterAddress calls `rb_gc_register_address` in C
//
// Original definition is following
//
//	void rb_gc_register_address(VALUE *valptr)
func RbGcRegisterAddress(valptr *VALUE) {
	C.rb_gc_register_address((*C.VALUE)(valptr))
}

// RbGcRegisterMarkObject calls `rb_gc_register_mark_object` in C
//
// Original definition is following
//
//	void rb_gc_register_mark_object(VALUE object)
func RbGcRegisterMarkObject(object VALUE) {
	C.rb_gc_register_mark_object(C.VALUE(object))
}

// RbGcStart calls `rb_gc_start` in C
//
// Original definition is following
//
//	VALUE rb_gc_start(void)
func RbGcStart() VALUE {
	return VALUE(C.rb_gc_start())
}

// RbGcStat calls `rb_gc_stat` in C
//
// Original definition is following
//
//	size_t rb_gc_stat(VALUE key_or_buf)
func RbGcStat(key_or_buf VALUE) SizeT {
	return SizeT(C.rb_gc_stat(C.VALUE(key_or_buf)))
}

// RbGcUnregisterAddress calls `rb_gc_unregister_address` in C
//
// Original definition is following
//
//	void rb_gc_unregister_address(VALUE *valptr)
func RbGcUnregisterAddress(valptr *VALUE) {
	C.rb_gc_unregister_address((*C.VALUE)(valptr))
}

// RbGcUpdateTblRefs calls `rb_gc_update_tbl_refs` in C
//
// Original definition is following
//
//	void rb_gc_update_tbl_refs(st_table *ptr)
func RbGcUpdateTblRefs(ptr *StTable) {
	var cPtr C.st_table
	C.rb_gc_update_tbl_refs(&cPtr)
	*ptr = StTable(cPtr)
}

// RbGcWritebarrier calls `rb_gc_writebarrier` in C
//
// Original definition is following
//
//	void rb_gc_writebarrier(VALUE old, VALUE young)
func RbGcWritebarrier(old VALUE, young VALUE) {
	C.rb_gc_writebarrier(C.VALUE(old), C.VALUE(young))
}

// RbGcWritebarrierUnprotect calls `rb_gc_writebarrier_unprotect` in C
//
// Original definition is following
//
//	void rb_gc_writebarrier_unprotect(VALUE obj)
func RbGcWritebarrierUnprotect(obj VALUE) {
	C.rb_gc_writebarrier_unprotect(C.VALUE(obj))
}

// RbGenrandInt32 calls `rb_genrand_int32` in C
//
// Original definition is following
//
//	unsigned int rb_genrand_int32(void)
func RbGenrandInt32() uint {
	return uint(C.rb_genrand_int32())
}

// RbGenrandReal calls `rb_genrand_real` in C
//
// Original definition is following
//
//	double rb_genrand_real(void)
func RbGenrandReal() Double {
	return Double(C.rb_genrand_real())
}

// RbGenrandUlongLimited calls `rb_genrand_ulong_limited` in C
//
// Original definition is following
//
//	unsigned long rb_genrand_ulong_limited(unsigned long i)
func RbGenrandUlongLimited(i uint) uint {
	return uint(C.rb_genrand_ulong_limited(C.ulong(i)))
}

// RbGetAllocFunc calls `rb_get_alloc_func` in C
//
// Original definition is following
//
//	rb_alloc_func_t rb_get_alloc_func(VALUE klass)
func RbGetAllocFunc(klass VALUE) unsafe.Pointer {
	return unsafe.Pointer(C.rb_get_alloc_func(C.VALUE(klass)))
}

// RbGetArgv calls `rb_get_argv` in C
//
// Original definition is following
//
//	VALUE rb_get_argv(void)
func RbGetArgv() VALUE {
	return VALUE(C.rb_get_argv())
}

// RbGetKwargs calls `rb_get_kwargs` in C
//
// Original definition is following
//
//	int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
func RbGetKwargs(keyword_hash VALUE, table *ID, required int, optional int, values *VALUE) int {
	var cTable C.ID
	var cValues C.VALUE
	ret := int(C.rb_get_kwargs(C.VALUE(keyword_hash), &cTable, C.int(required), C.int(optional), &cValues))
	*table = ID(cTable)
	*values = VALUE(cValues)
	return ret
}

// RbGetPath calls `rb_get_path` in C
//
// Original definition is following
//
//	VALUE rb_get_path(VALUE obj)
func RbGetPath(obj VALUE) VALUE {
	return VALUE(C.rb_get_path(C.VALUE(obj)))
}

// RbGetPathNoChecksafe calls `rb_get_path_no_checksafe` in C
//
// Original definition is following
//
//	VALUE rb_get_path_no_checksafe(VALUE)
func RbGetPathNoChecksafe(arg1 VALUE) VALUE {
	return VALUE(C.rb_get_path_no_checksafe(C.VALUE(arg1)))
}

// RbGetValuesAt calls `rb_get_values_at` in C
//
// Original definition is following
//
//	VALUE rb_get_values_at(VALUE obj, long olen, int argc, const VALUE *argv, VALUE (*func)(VALUE obj, long oidx))
func RbGetValuesAt(obj VALUE, olen Long, argc int, argv *VALUE, arg5 unsafe.Pointer) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_get_values_at(C.VALUE(obj), C.long(olen), C.int(argc), &cArgv, toCFunctionPointer(arg5)))
	*argv = VALUE(cArgv)
	return ret
}

// RbGets calls `rb_gets` in C
//
// Original definition is following
//
//	VALUE rb_gets(void)
func RbGets() VALUE {
	return VALUE(C.rb_gets())
}

// RbGlob calls `rb_glob` in C
//
// Original definition is following
//
//	void rb_glob(const char *pattern, void (*func)(const char *path, VALUE arg, void *enc), VALUE arg)
func RbGlob(pattern string, arg2 unsafe.Pointer, arg VALUE) {
	char, clean := string2Char(pattern)
	defer clean()

	C.rb_glob(char, toCFunctionPointer(arg2), C.VALUE(arg))
}

// RbGlobalVariable calls `rb_global_variable` in C
//
// Original definition is following
//
//	void rb_global_variable(VALUE *)
func RbGlobalVariable(arg1 *VALUE) {
	var cArg1 C.VALUE
	C.rb_global_variable(&cArg1)
	*arg1 = VALUE(cArg1)
}

// RbGvGet calls `rb_gv_get` in C
//
// Original definition is following
//
//	VALUE rb_gv_get(const char *name)
func RbGvGet(name string) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_gv_get(char))
}

// RbGvSet calls `rb_gv_set` in C
//
// Original definition is following
//
//	VALUE rb_gv_set(const char *name, VALUE val)
func RbGvSet(name string, val VALUE) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_gv_set(char, C.VALUE(val)))
}

// RbHash calls `rb_hash` in C
//
// Original definition is following
//
//	VALUE rb_hash(VALUE obj)
func RbHash(obj VALUE) VALUE {
	return VALUE(C.rb_hash(C.VALUE(obj)))
}

// RbHashAref calls `rb_hash_aref` in C
//
// Original definition is following
//
//	VALUE rb_hash_aref(VALUE hash, VALUE key)
func RbHashAref(hash VALUE, key VALUE) VALUE {
	return VALUE(C.rb_hash_aref(C.VALUE(hash), C.VALUE(key)))
}

// RbHashAset calls `rb_hash_aset` in C
//
// Original definition is following
//
//	VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
func RbHashAset(hash VALUE, key VALUE, val VALUE) VALUE {
	return VALUE(C.rb_hash_aset(C.VALUE(hash), C.VALUE(key), C.VALUE(val)))
}

// RbHashBulkInsert calls `rb_hash_bulk_insert` in C
//
// Original definition is following
//
//	void rb_hash_bulk_insert(long argc, const VALUE *argv, VALUE hash)
func RbHashBulkInsert(argc Long, argv *VALUE, hash VALUE) {
	var cArgv C.VALUE
	C.rb_hash_bulk_insert(C.long(argc), &cArgv, C.VALUE(hash))
	*argv = VALUE(cArgv)
}

// RbHashBulkInsertIntoStTable calls `rb_hash_bulk_insert_into_st_table` in C
//
// Original definition is following
//
//	void rb_hash_bulk_insert_into_st_table(long, const VALUE *, VALUE)
func RbHashBulkInsertIntoStTable(arg1 Long, arg2 *VALUE, arg3 VALUE) {
	var cArg2 C.VALUE
	C.rb_hash_bulk_insert_into_st_table(C.long(arg1), &cArg2, C.VALUE(arg3))
	*arg2 = VALUE(cArg2)
}

// RbHashClear calls `rb_hash_clear` in C
//
// Original definition is following
//
//	VALUE rb_hash_clear(VALUE hash)
func RbHashClear(hash VALUE) VALUE {
	return VALUE(C.rb_hash_clear(C.VALUE(hash)))
}

// RbHashDelete calls `rb_hash_delete` in C
//
// Original definition is following
//
//	VALUE rb_hash_delete(VALUE hash, VALUE key)
func RbHashDelete(hash VALUE, key VALUE) VALUE {
	return VALUE(C.rb_hash_delete(C.VALUE(hash), C.VALUE(key)))
}

// RbHashDeleteIf calls `rb_hash_delete_if` in C
//
// Original definition is following
//
//	VALUE rb_hash_delete_if(VALUE hash)
func RbHashDeleteIf(hash VALUE) VALUE {
	return VALUE(C.rb_hash_delete_if(C.VALUE(hash)))
}

// RbHashDup calls `rb_hash_dup` in C
//
// Original definition is following
//
//	VALUE rb_hash_dup(VALUE hash)
func RbHashDup(hash VALUE) VALUE {
	return VALUE(C.rb_hash_dup(C.VALUE(hash)))
}

// RbHashFetch calls `rb_hash_fetch` in C
//
// Original definition is following
//
//	VALUE rb_hash_fetch(VALUE hash, VALUE key)
func RbHashFetch(hash VALUE, key VALUE) VALUE {
	return VALUE(C.rb_hash_fetch(C.VALUE(hash), C.VALUE(key)))
}

// RbHashForeach calls `rb_hash_foreach` in C
//
// Original definition is following
//
//	void rb_hash_foreach(VALUE hash, int (*func)(VALUE key, VALUE val, VALUE arg), VALUE arg)
func RbHashForeach(hash VALUE, arg2 unsafe.Pointer, arg VALUE) {
	C.rb_hash_foreach(C.VALUE(hash), toCFunctionPointer(arg2), C.VALUE(arg))
}

// RbHashFreeze calls `rb_hash_freeze` in C
//
// Original definition is following
//
//	VALUE rb_hash_freeze(VALUE obj)
func RbHashFreeze(obj VALUE) VALUE {
	return VALUE(C.rb_hash_freeze(C.VALUE(obj)))
}

// RbHashLookup calls `rb_hash_lookup` in C
//
// Original definition is following
//
//	VALUE rb_hash_lookup(VALUE hash, VALUE key)
func RbHashLookup(hash VALUE, key VALUE) VALUE {
	return VALUE(C.rb_hash_lookup(C.VALUE(hash), C.VALUE(key)))
}

// RbHashLookup2 calls `rb_hash_lookup2` in C
//
// Original definition is following
//
//	VALUE rb_hash_lookup2(VALUE hash, VALUE key, VALUE def)
func RbHashLookup2(hash VALUE, key VALUE, def VALUE) VALUE {
	return VALUE(C.rb_hash_lookup2(C.VALUE(hash), C.VALUE(key), C.VALUE(def)))
}

// RbHashNew calls `rb_hash_new` in C
//
// Original definition is following
//
//	VALUE rb_hash_new(void)
func RbHashNew() VALUE {
	return VALUE(C.rb_hash_new())
}

// RbHashNewCapa calls `rb_hash_new_capa` in C
//
// Original definition is following
//
//	VALUE rb_hash_new_capa(long capa)
func RbHashNewCapa(capa Long) VALUE {
	return VALUE(C.rb_hash_new_capa(C.long(capa)))
}

// RbHashSetIfnone calls `rb_hash_set_ifnone` in C
//
// Original definition is following
//
//	VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone)
func RbHashSetIfnone(hash VALUE, ifnone VALUE) VALUE {
	return VALUE(C.rb_hash_set_ifnone(C.VALUE(hash), C.VALUE(ifnone)))
}

// RbHashSize calls `rb_hash_size` in C
//
// Original definition is following
//
//	VALUE rb_hash_size(VALUE hash)
func RbHashSize(hash VALUE) VALUE {
	return VALUE(C.rb_hash_size(C.VALUE(hash)))
}

// RbHashSizeNum calls `rb_hash_size_num` in C
//
// Original definition is following
//
//	size_t rb_hash_size_num(VALUE hash)
func RbHashSizeNum(hash VALUE) SizeT {
	return SizeT(C.rb_hash_size_num(C.VALUE(hash)))
}

// RbHashStart calls `rb_hash_start` in C
//
// Original definition is following
//
//	st_index_t rb_hash_start(st_index_t i)
func RbHashStart(i StIndexT) StIndexT {
	return StIndexT(C.rb_hash_start(C.st_index_t(i)))
}

// RbHashTbl calls `rb_hash_tbl` in C
//
// Original definition is following
//
//	struct st_table *rb_hash_tbl(VALUE hash, const char *file, int line)
func RbHashTbl(hash VALUE, file string, line int) *StTable {
	char, clean := string2Char(file)
	defer clean()

	return (*StTable)(C.rb_hash_tbl(C.VALUE(hash), char, C.int(line)))
}

// RbHashUpdateBy calls `rb_hash_update_by` in C
//
// Original definition is following
//
//	VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func)
func RbHashUpdateBy(hash1 VALUE, hash2 VALUE, fun *RbHashUpdateFunc) VALUE {
	var cFun C.rb_hash_update_func
	ret := VALUE(C.rb_hash_update_by(C.VALUE(hash1), C.VALUE(hash2), &cFun))
	*fun = RbHashUpdateFunc(cFun)
	return ret
}

// RbId2Name calls `rb_id2name` in C
//
// Original definition is following
//
//	const char *rb_id2name(ID id)
func RbId2Name(id ID) string {
	return char2String(C.rb_id2name(C.ID(id)))
}

// RbId2Str calls `rb_id2str` in C
//
// Original definition is following
//
//	VALUE rb_id2str(ID id)
func RbId2Str(id ID) VALUE {
	return VALUE(C.rb_id2str(C.ID(id)))
}

// RbId2Sym calls `rb_id2sym` in C
//
// Original definition is following
//
//	VALUE rb_id2sym(ID id)
func RbId2Sym(id ID) VALUE {
	return VALUE(C.rb_id2sym(C.ID(id)))
}

// RbIdAttrset calls `rb_id_attrset` in C
//
// Original definition is following
//
//	ID rb_id_attrset(ID id)
func RbIdAttrset(id ID) ID {
	return ID(C.rb_id_attrset(C.ID(id)))
}

// RbIncludeModule calls `rb_include_module` in C
//
// Original definition is following
//
//	void rb_include_module(VALUE klass, VALUE module)
func RbIncludeModule(klass VALUE, module VALUE) {
	C.rb_include_module(C.VALUE(klass), C.VALUE(module))
}

// RbInspect calls `rb_inspect` in C
//
// Original definition is following
//
//	VALUE rb_inspect(VALUE obj)
func RbInspect(obj VALUE) VALUE {
	return VALUE(C.rb_inspect(C.VALUE(obj)))
}

// RbInt2Big calls `rb_int2big` in C
//
// Original definition is following
//
//	VALUE rb_int2big(intptr_t i)
func RbInt2Big(i IntptrT) VALUE {
	return VALUE(C.rb_int2big(C.intptr_t(i)))
}

// RbInt2Inum calls `rb_int2inum` in C
//
// Original definition is following
//
//	VALUE rb_int2inum(intptr_t i)
func RbInt2Inum(i IntptrT) VALUE {
	return VALUE(C.rb_int2inum(C.intptr_t(i)))
}

// RbInt2NumInline calls `rb_int2num_inline` in C
//
// Original definition is following
//
//	rb_int2num_inline(int v)
func RbInt2NumInline(v int) VALUE {
	return VALUE(C.rb_int2num_inline(C.int(v)))
}

// RbIntPositivePow calls `rb_int_positive_pow` in C
//
// Original definition is following
//
//	extern VALUE rb_int_positive_pow(long x, unsigned long y)
func RbIntPositivePow(x Long, y uint) VALUE {
	return VALUE(C.rb_int_positive_pow(C.long(x), C.ulong(y)))
}

// RbIntegerPack calls `rb_integer_pack` in C
//
// Original definition is following
//
//	int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
func RbIntegerPack(val VALUE, words unsafe.Pointer, numwords SizeT, wordsize SizeT, nails SizeT, flags int) int {
	return int(C.rb_integer_pack(C.VALUE(val), words, C.size_t(numwords), C.size_t(wordsize), C.size_t(nails), C.int(flags)))
}

// RbIntegerTypeP calls `rb_integer_type_p` in C
//
// Original definition is following
//
//	rb_integer_type_p(VALUE obj)
func RbIntegerTypeP(obj VALUE) Bool {
	return Bool(C.rb_integer_type_p(C.VALUE(obj)))
}

// RbIntegerUnpack calls `rb_integer_unpack` in C
//
// Original definition is following
//
//	VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
func RbIntegerUnpack(words unsafe.Pointer, numwords SizeT, wordsize SizeT, nails SizeT, flags int) VALUE {
	return VALUE(C.rb_integer_unpack(words, C.size_t(numwords), C.size_t(wordsize), C.size_t(nails), C.int(flags)))
}

// RbIntern calls `rb_intern` in C
//
// Original definition is following
//
//	ID rb_intern(const char *name)
func RbIntern(name string) ID {
	char, clean := string2Char(name)
	defer clean()

	return ID(C.rb_intern(char))
}

// RbIntern2 calls `rb_intern2` in C
//
// Original definition is following
//
//	ID rb_intern2(const char *name, long len)
func RbIntern2(name string, len Long) ID {
	char, clean := string2Char(name)
	defer clean()

	return ID(C.rb_intern2(char, C.long(len)))
}

// RbInternConst calls `rb_intern_const` in C
//
// Original definition is following
//
//	rb_intern_const(const char *str)
func RbInternConst(str string) ID {
	char, clean := string2Char(str)
	defer clean()

	return ID(C.rb_intern_const(char))
}

// RbInternStr calls `rb_intern_str` in C
//
// Original definition is following
//
//	ID rb_intern_str(VALUE str)
func RbInternStr(str VALUE) ID {
	return ID(C.rb_intern_str(C.VALUE(str)))
}

// RbInternedStr calls `rb_interned_str` in C
//
// Original definition is following
//
//	VALUE rb_interned_str(const char *ptr, long len)
func RbInternedStr(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_interned_str(char, C.long(len)))
}

// RbInternedStrCstr calls `rb_interned_str_cstr` in C
//
// Original definition is following
//
//	VALUE rb_interned_str_cstr(const char *ptr)
func RbInternedStrCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_interned_str_cstr(char))
}

// RbInterrupt calls `rb_interrupt` in C
//
// Original definition is following
//
//	void rb_interrupt(void)
func RbInterrupt() {
	C.rb_interrupt()
}

// RbInvalidStr calls `rb_invalid_str` in C
//
// Original definition is following
//
//	void rb_invalid_str(const char *str, const char *type)
func RbInvalidStr(str string, t string) {
	charStr, cleanCharstr := string2Char(str)
	defer cleanCharstr()

	charT, cleanChart := string2Char(t)
	defer cleanChart()

	C.rb_invalid_str(charStr, charT)
}

// RbIoAddstr calls `rb_io_addstr` in C
//
// Original definition is following
//
//	VALUE rb_io_addstr(VALUE io, VALUE str)
func RbIoAddstr(io VALUE, str VALUE) VALUE {
	return VALUE(C.rb_io_addstr(C.VALUE(io), C.VALUE(str)))
}

// RbIoAscii8BitBinmode calls `rb_io_ascii8bit_binmode` in C
//
// Original definition is following
//
//	VALUE rb_io_ascii8bit_binmode(VALUE io)
func RbIoAscii8BitBinmode(io VALUE) VALUE {
	return VALUE(C.rb_io_ascii8bit_binmode(C.VALUE(io)))
}

// RbIoBinmode calls `rb_io_binmode` in C
//
// Original definition is following
//
//	VALUE rb_io_binmode(VALUE io)
func RbIoBinmode(io VALUE) VALUE {
	return VALUE(C.rb_io_binmode(C.VALUE(io)))
}

// RbIoClose calls `rb_io_close` in C
//
// Original definition is following
//
//	VALUE rb_io_close(VALUE io)
func RbIoClose(io VALUE) VALUE {
	return VALUE(C.rb_io_close(C.VALUE(io)))
}

// RbIoEof calls `rb_io_eof` in C
//
// Original definition is following
//
//	VALUE rb_io_eof(VALUE io)
func RbIoEof(io VALUE) VALUE {
	return VALUE(C.rb_io_eof(C.VALUE(io)))
}

// RbIoFdopen calls `rb_io_fdopen` in C
//
// Original definition is following
//
//	VALUE rb_io_fdopen(int fd, int flags, const char *path)
func RbIoFdopen(fd int, flags int, path string) VALUE {
	char, clean := string2Char(path)
	defer clean()

	return VALUE(C.rb_io_fdopen(C.int(fd), C.int(flags), char))
}

// RbIoFlush calls `rb_io_flush` in C
//
// Original definition is following
//
//	VALUE rb_io_flush(VALUE io)
func RbIoFlush(io VALUE) VALUE {
	return VALUE(C.rb_io_flush(C.VALUE(io)))
}

// RbIoGetbyte calls `rb_io_getbyte` in C
//
// Original definition is following
//
//	VALUE rb_io_getbyte(VALUE io)
func RbIoGetbyte(io VALUE) VALUE {
	return VALUE(C.rb_io_getbyte(C.VALUE(io)))
}

// RbIoGets calls `rb_io_gets` in C
//
// Original definition is following
//
//	VALUE rb_io_gets(VALUE io)
func RbIoGets(io VALUE) VALUE {
	return VALUE(C.rb_io_gets(C.VALUE(io)))
}

// RbIoPrint calls `rb_io_print` in C
//
// Original definition is following
//
//	VALUE rb_io_print(int argc, const VALUE *argv, VALUE io)
func RbIoPrint(argc int, argv *VALUE, io VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_io_print(C.int(argc), &cArgv, C.VALUE(io)))
	*argv = VALUE(cArgv)
	return ret
}

// RbIoPrintf calls `rb_io_printf` in C
//
// Original definition is following
//
//	VALUE rb_io_printf(int argc, const VALUE *argv, VALUE io)
func RbIoPrintf(argc int, argv *VALUE, io VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_io_printf(C.int(argc), &cArgv, C.VALUE(io)))
	*argv = VALUE(cArgv)
	return ret
}

// RbIoPuts calls `rb_io_puts` in C
//
// Original definition is following
//
//	VALUE rb_io_puts(int argc, const VALUE *argv, VALUE io)
func RbIoPuts(argc int, argv *VALUE, io VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_io_puts(C.int(argc), &cArgv, C.VALUE(io)))
	*argv = VALUE(cArgv)
	return ret
}

// RbIoUngetbyte calls `rb_io_ungetbyte` in C
//
// Original definition is following
//
//	VALUE rb_io_ungetbyte(VALUE io, VALUE b)
func RbIoUngetbyte(io VALUE, b VALUE) VALUE {
	return VALUE(C.rb_io_ungetbyte(C.VALUE(io), C.VALUE(b)))
}

// RbIoUngetc calls `rb_io_ungetc` in C
//
// Original definition is following
//
//	VALUE rb_io_ungetc(VALUE io, VALUE c)
func RbIoUngetc(io VALUE, c VALUE) VALUE {
	return VALUE(C.rb_io_ungetc(C.VALUE(io), C.VALUE(c)))
}

// RbIoWrite calls `rb_io_write` in C
//
// Original definition is following
//
//	VALUE rb_io_write(VALUE io, VALUE str)
func RbIoWrite(io VALUE, str VALUE) VALUE {
	return VALUE(C.rb_io_write(C.VALUE(io), C.VALUE(str)))
}

// RbIsAbsolutePath calls `rb_is_absolute_path` in C
//
// Original definition is following
//
//	int rb_is_absolute_path(const char *path)
func RbIsAbsolutePath(path string) int {
	char, clean := string2Char(path)
	defer clean()

	return int(C.rb_is_absolute_path(char))
}

// RbIsAttrsetId calls `rb_is_attrset_id` in C
//
// Original definition is following
//
//	int rb_is_attrset_id(ID id)
func RbIsAttrsetId(id ID) int {
	return int(C.rb_is_attrset_id(C.ID(id)))
}

// RbIsClassId calls `rb_is_class_id` in C
//
// Original definition is following
//
//	int rb_is_class_id(ID id)
func RbIsClassId(id ID) int {
	return int(C.rb_is_class_id(C.ID(id)))
}

// RbIsConstId calls `rb_is_const_id` in C
//
// Original definition is following
//
//	int rb_is_const_id(ID id)
func RbIsConstId(id ID) int {
	return int(C.rb_is_const_id(C.ID(id)))
}

// RbIsGlobalId calls `rb_is_global_id` in C
//
// Original definition is following
//
//	int rb_is_global_id(ID id)
func RbIsGlobalId(id ID) int {
	return int(C.rb_is_global_id(C.ID(id)))
}

// RbIsInstanceId calls `rb_is_instance_id` in C
//
// Original definition is following
//
//	int rb_is_instance_id(ID id)
func RbIsInstanceId(id ID) int {
	return int(C.rb_is_instance_id(C.ID(id)))
}

// RbIsJunkId calls `rb_is_junk_id` in C
//
// Original definition is following
//
//	int rb_is_junk_id(ID)
func RbIsJunkId(arg1 ID) int {
	return int(C.rb_is_junk_id(C.ID(arg1)))
}

// RbIsLocalId calls `rb_is_local_id` in C
//
// Original definition is following
//
//	int rb_is_local_id(ID id)
func RbIsLocalId(id ID) int {
	return int(C.rb_is_local_id(C.ID(id)))
}

// RbIsalnum calls `rb_isalnum` in C
//
// Original definition is following
//
//	rb_isalnum(int c)
func RbIsalnum(c int) int {
	return int(C.rb_isalnum(C.int(c)))
}

// RbIsalpha calls `rb_isalpha` in C
//
// Original definition is following
//
//	rb_isalpha(int c)
func RbIsalpha(c int) int {
	return int(C.rb_isalpha(C.int(c)))
}

// RbIsascii calls `rb_isascii` in C
//
// Original definition is following
//
//	rb_isascii(int c)
func RbIsascii(c int) int {
	return int(C.rb_isascii(C.int(c)))
}

// RbIsblank calls `rb_isblank` in C
//
// Original definition is following
//
//	rb_isblank(int c)
func RbIsblank(c int) int {
	return int(C.rb_isblank(C.int(c)))
}

// RbIscntrl calls `rb_iscntrl` in C
//
// Original definition is following
//
//	rb_iscntrl(int c)
func RbIscntrl(c int) int {
	return int(C.rb_iscntrl(C.int(c)))
}

// RbIsdigit calls `rb_isdigit` in C
//
// Original definition is following
//
//	rb_isdigit(int c)
func RbIsdigit(c int) int {
	return int(C.rb_isdigit(C.int(c)))
}

// RbIsgraph calls `rb_isgraph` in C
//
// Original definition is following
//
//	rb_isgraph(int c)
func RbIsgraph(c int) int {
	return int(C.rb_isgraph(C.int(c)))
}

// RbIslower calls `rb_islower` in C
//
// Original definition is following
//
//	rb_islower(int c)
func RbIslower(c int) int {
	return int(C.rb_islower(C.int(c)))
}

// RbIsprint calls `rb_isprint` in C
//
// Original definition is following
//
//	rb_isprint(int c)
func RbIsprint(c int) int {
	return int(C.rb_isprint(C.int(c)))
}

// RbIspunct calls `rb_ispunct` in C
//
// Original definition is following
//
//	rb_ispunct(int c)
func RbIspunct(c int) int {
	return int(C.rb_ispunct(C.int(c)))
}

// RbIsspace calls `rb_isspace` in C
//
// Original definition is following
//
//	rb_isspace(int c)
func RbIsspace(c int) int {
	return int(C.rb_isspace(C.int(c)))
}

// RbIsupper calls `rb_isupper` in C
//
// Original definition is following
//
//	rb_isupper(int c)
func RbIsupper(c int) int {
	return int(C.rb_isupper(C.int(c)))
}

// RbIsxdigit calls `rb_isxdigit` in C
//
// Original definition is following
//
//	rb_isxdigit(int c)
func RbIsxdigit(c int) int {
	return int(C.rb_isxdigit(C.int(c)))
}

// RbIterBreak calls `rb_iter_break` in C
//
// Original definition is following
//
//	void rb_iter_break(void)
func RbIterBreak() {
	C.rb_iter_break()
}

// RbIterBreakValue calls `rb_iter_break_value` in C
//
// Original definition is following
//
//	void rb_iter_break_value(VALUE val)
func RbIterBreakValue(val VALUE) {
	C.rb_iter_break_value(C.VALUE(val))
}

// RbIvGet calls `rb_iv_get` in C
//
// Original definition is following
//
//	VALUE rb_iv_get(VALUE obj, const char *name)
func RbIvGet(obj VALUE, name string) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_iv_get(C.VALUE(obj), char))
}

// RbIvSet calls `rb_iv_set` in C
//
// Original definition is following
//
//	VALUE rb_iv_set(VALUE obj, const char *name, VALUE val)
func RbIvSet(obj VALUE, name string, val VALUE) VALUE {
	char, clean := string2Char(name)
	defer clean()

	return VALUE(C.rb_iv_set(C.VALUE(obj), char, C.VALUE(val)))
}

// RbIvarCount calls `rb_ivar_count` in C
//
// Original definition is following
//
//	st_index_t rb_ivar_count(VALUE obj)
func RbIvarCount(obj VALUE) StIndexT {
	return StIndexT(C.rb_ivar_count(C.VALUE(obj)))
}

// RbIvarDefined calls `rb_ivar_defined` in C
//
// Original definition is following
//
//	VALUE rb_ivar_defined(VALUE obj, ID name)
func RbIvarDefined(obj VALUE, name ID) VALUE {
	return VALUE(C.rb_ivar_defined(C.VALUE(obj), C.ID(name)))
}

// RbIvarForeach calls `rb_ivar_foreach` in C
//
// Original definition is following
//
//	void rb_ivar_foreach(VALUE obj, int (*func)(ID name, VALUE val, st_data_t arg), st_data_t arg)
func RbIvarForeach(obj VALUE, arg2 unsafe.Pointer, arg StDataT) {
	C.rb_ivar_foreach(C.VALUE(obj), toCFunctionPointer(arg2), C.st_data_t(arg))
}

// RbIvarGet calls `rb_ivar_get` in C
//
// Original definition is following
//
//	VALUE rb_ivar_get(VALUE obj, ID name)
func RbIvarGet(obj VALUE, name ID) VALUE {
	return VALUE(C.rb_ivar_get(C.VALUE(obj), C.ID(name)))
}

// RbIvarSet calls `rb_ivar_set` in C
//
// Original definition is following
//
//	VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
func RbIvarSet(obj VALUE, name ID, val VALUE) VALUE {
	return VALUE(C.rb_ivar_set(C.VALUE(obj), C.ID(name), C.VALUE(val)))
}

// RbJumpTag calls `rb_jump_tag` in C
//
// Original definition is following
//
//	void rb_jump_tag(int state)
func RbJumpTag(state int) {
	C.rb_jump_tag(C.int(state))
}

// RbKeywordGivenP calls `rb_keyword_given_p` in C
//
// Original definition is following
//
//	int rb_keyword_given_p(void)
func RbKeywordGivenP() int {
	return int(C.rb_keyword_given_p())
}

// RbLastStatusGet calls `rb_last_status_get` in C
//
// Original definition is following
//
//	VALUE rb_last_status_get(void)
func RbLastStatusGet() VALUE {
	return VALUE(C.rb_last_status_get())
}

// RbLastStatusSet calls `rb_last_status_set` in C
//
// Original definition is following
//
//	void rb_last_status_set(int status, pid_t pid)
func RbLastStatusSet(status int, pid PidT) {
	C.rb_last_status_set(C.int(status), C.pid_t(pid))
}

// RbLastlineGet calls `rb_lastline_get` in C
//
// Original definition is following
//
//	VALUE rb_lastline_get(void)
func RbLastlineGet() VALUE {
	return VALUE(C.rb_lastline_get())
}

// RbLastlineSet calls `rb_lastline_set` in C
//
// Original definition is following
//
//	void rb_lastline_set(VALUE str)
func RbLastlineSet(str VALUE) {
	C.rb_lastline_set(C.VALUE(str))
}

// RbLl2Inum calls `rb_ll2inum` in C
//
// Original definition is following
//
//	VALUE rb_ll2inum(
func RbLl2Inum(num Longlong) VALUE {
	return VALUE(C.rb_ll2inum(C.longlong(num)))
}

// RbLl2NumInline calls `rb_ll2num_inline` in C
//
// Original definition is following
//
//	rb_ll2num_inline(
func RbLl2NumInline(n Longlong) VALUE {
	return VALUE(C.rb_ll2num_inline(C.longlong(n)))
}

// RbLoad calls `rb_load` in C
//
// Original definition is following
//
//	void rb_load(VALUE path, int wrap)
func RbLoad(path VALUE, wrap int) {
	C.rb_load(C.VALUE(path), C.int(wrap))
}

// RbLoadFile calls `rb_load_file` in C
//
// Original definition is following
//
//	void *rb_load_file(const char *file)
func RbLoadFile(file string) unsafe.Pointer {
	char, clean := string2Char(file)
	defer clean()

	return unsafe.Pointer(C.rb_load_file(char))
}

// RbLoadFileStr calls `rb_load_file_str` in C
//
// Original definition is following
//
//	void *rb_load_file_str(VALUE file)
func RbLoadFileStr(file VALUE) unsafe.Pointer {
	return unsafe.Pointer(C.rb_load_file_str(C.VALUE(file)))
}

// RbLoadProtect calls `rb_load_protect` in C
//
// Original definition is following
//
//	void rb_load_protect(VALUE path, int wrap, int *state)
func RbLoadProtect(path VALUE, wrap int, state *int) {
	var cState C.int
	C.rb_load_protect(C.VALUE(path), C.int(wrap), &cState)
	*state = int(cState)
}

// RbLocaleStrNew calls `rb_locale_str_new` in C
//
// Original definition is following
//
//	VALUE rb_locale_str_new(const char *ptr, long len)
func RbLocaleStrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_locale_str_new(char, C.long(len)))
}

// RbLocaleStrNewCstr calls `rb_locale_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_locale_str_new_cstr(const char *ptr)
func RbLocaleStrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_locale_str_new_cstr(char))
}

// RbLong2IntInline calls `rb_long2int_inline` in C
//
// Original definition is following
//
//	rb_long2int_inline(long n)
func RbLong2IntInline(n Long) int {
	return int(C.rb_long2int_inline(C.long(n)))
}

// RbLong2NumInline calls `rb_long2num_inline` in C
//
// Original definition is following
//
//	rb_long2num_inline(long v)
func RbLong2NumInline(v Long) VALUE {
	return VALUE(C.rb_long2num_inline(C.long(v)))
}

// RbMakeBacktrace calls `rb_make_backtrace` in C
//
// Original definition is following
//
//	VALUE rb_make_backtrace(void)
func RbMakeBacktrace() VALUE {
	return VALUE(C.rb_make_backtrace())
}

// RbMakeException calls `rb_make_exception` in C
//
// Original definition is following
//
//	VALUE rb_make_exception(int argc, const VALUE *argv)
func RbMakeException(argc int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_make_exception(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbMarkHash calls `rb_mark_hash` in C
//
// Original definition is following
//
//	void rb_mark_hash(struct st_table *tbl)
func RbMarkHash(tbl *StTable) {
	var cTbl C.st_table
	C.rb_mark_hash(&cTbl)
	*tbl = StTable(cTbl)
}

// RbMarkSet calls `rb_mark_set` in C
//
// Original definition is following
//
//	void rb_mark_set(struct st_table *tbl)
func RbMarkSet(tbl *StTable) {
	var cTbl C.st_table
	C.rb_mark_set(&cTbl)
	*tbl = StTable(cTbl)
}

// RbMarkTbl calls `rb_mark_tbl` in C
//
// Original definition is following
//
//	void rb_mark_tbl(struct st_table *tbl)
func RbMarkTbl(tbl *StTable) {
	var cTbl C.st_table
	C.rb_mark_tbl(&cTbl)
	*tbl = StTable(cTbl)
}

// RbMarkTblNoPin calls `rb_mark_tbl_no_pin` in C
//
// Original definition is following
//
//	void rb_mark_tbl_no_pin(struct st_table *tbl)
func RbMarkTblNoPin(tbl *StTable) {
	var cTbl C.st_table
	C.rb_mark_tbl_no_pin(&cTbl)
	*tbl = StTable(cTbl)
}

// RbMarshalDefineCompat calls `rb_marshal_define_compat` in C
//
// Original definition is following
//
//	void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE))
func RbMarshalDefineCompat(newclass VALUE, oldclass VALUE, arg3 unsafe.Pointer, arg4 unsafe.Pointer) {
	C.rb_marshal_define_compat(C.VALUE(newclass), C.VALUE(oldclass), toCFunctionPointer(arg3), toCFunctionPointer(arg4))
}

// RbMarshalDump calls `rb_marshal_dump` in C
//
// Original definition is following
//
//	VALUE rb_marshal_dump(VALUE obj, VALUE port)
func RbMarshalDump(obj VALUE, port VALUE) VALUE {
	return VALUE(C.rb_marshal_dump(C.VALUE(obj), C.VALUE(port)))
}

// RbMarshalLoad calls `rb_marshal_load` in C
//
// Original definition is following
//
//	VALUE rb_marshal_load(VALUE port)
func RbMarshalLoad(port VALUE) VALUE {
	return VALUE(C.rb_marshal_load(C.VALUE(port)))
}

// RbMatchBusy calls `rb_match_busy` in C
//
// Original definition is following
//
//	void rb_match_busy(VALUE md)
func RbMatchBusy(md VALUE) {
	C.rb_match_busy(C.VALUE(md))
}

// RbMemClear calls `rb_mem_clear` in C
//
// Original definition is following
//
//	void rb_mem_clear(VALUE *buf, long len)
func RbMemClear(buf *VALUE, len Long) {
	var cBuf C.VALUE
	C.rb_mem_clear(&cBuf, C.long(len))
	*buf = VALUE(cBuf)
}

// RbMemcicmp calls `rb_memcicmp` in C
//
// Original definition is following
//
//	int rb_memcicmp(const void *s1,const void *s2, long n)
func RbMemcicmp(s1 unsafe.Pointer, s2 unsafe.Pointer, n Long) int {
	return int(C.rb_memcicmp(s1, s2, C.long(n)))
}

// RbMemerror calls `rb_memerror` in C
//
// Original definition is following
//
//	void rb_memerror(void)
func RbMemerror() {
	C.rb_memerror()
}

// RbMemhash calls `rb_memhash` in C
//
// Original definition is following
//
//	st_index_t rb_memhash(const void *ptr, long len)
func RbMemhash(ptr unsafe.Pointer, len Long) StIndexT {
	return StIndexT(C.rb_memhash(ptr, C.long(len)))
}

// RbMemoryId calls `rb_memory_id` in C
//
// Original definition is following
//
//	VALUE rb_memory_id(VALUE obj)
func RbMemoryId(obj VALUE) VALUE {
	return VALUE(C.rb_memory_id(C.VALUE(obj)))
}

// RbMethodBasicDefinitionP calls `rb_method_basic_definition_p` in C
//
// Original definition is following
//
//	int rb_method_basic_definition_p(VALUE klass, ID mid)
func RbMethodBasicDefinitionP(klass VALUE, mid ID) int {
	return int(C.rb_method_basic_definition_p(C.VALUE(klass), C.ID(mid)))
}

// RbMethodBoundp calls `rb_method_boundp` in C
//
// Original definition is following
//
//	int rb_method_boundp(VALUE klass, ID id, int ex)
func RbMethodBoundp(klass VALUE, id ID, ex int) int {
	return int(C.rb_method_boundp(C.VALUE(klass), C.ID(id), C.int(ex)))
}

// RbMethodCall calls `rb_method_call` in C
//
// Original definition is following
//
//	VALUE rb_method_call(int argc, const VALUE *argv, VALUE recv)
func RbMethodCall(argc int, argv *VALUE, recv VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_method_call(C.int(argc), &cArgv, C.VALUE(recv)))
	*argv = VALUE(cArgv)
	return ret
}

// RbMethodCallKw calls `rb_method_call_kw` in C
//
// Original definition is following
//
//	VALUE rb_method_call_kw(int argc, const VALUE *argv, VALUE recv, int kw_splat)
func RbMethodCallKw(argc int, argv *VALUE, recv VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_method_call_kw(C.int(argc), &cArgv, C.VALUE(recv), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbMethodCallWithBlock calls `rb_method_call_with_block` in C
//
// Original definition is following
//
//	VALUE rb_method_call_with_block(int argc, const VALUE *argv, VALUE recv, VALUE proc)
func RbMethodCallWithBlock(argc int, argv *VALUE, recv VALUE, proc VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_method_call_with_block(C.int(argc), &cArgv, C.VALUE(recv), C.VALUE(proc)))
	*argv = VALUE(cArgv)
	return ret
}

// RbMethodCallWithBlockKw calls `rb_method_call_with_block_kw` in C
//
// Original definition is following
//
//	VALUE rb_method_call_with_block_kw(int argc, const VALUE *argv, VALUE recv, VALUE proc, int kw_splat)
func RbMethodCallWithBlockKw(argc int, argv *VALUE, recv VALUE, proc VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_method_call_with_block_kw(C.int(argc), &cArgv, C.VALUE(recv), C.VALUE(proc), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbModAncestors calls `rb_mod_ancestors` in C
//
// Original definition is following
//
//	VALUE rb_mod_ancestors(VALUE mod)
func RbModAncestors(mod VALUE) VALUE {
	return VALUE(C.rb_mod_ancestors(C.VALUE(mod)))
}

// RbModClassVariables calls `rb_mod_class_variables` in C
//
// Original definition is following
//
//	VALUE rb_mod_class_variables(int argc, const VALUE *argv, VALUE recv)
func RbModClassVariables(argc int, argv *VALUE, recv VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_mod_class_variables(C.int(argc), &cArgv, C.VALUE(recv)))
	*argv = VALUE(cArgv)
	return ret
}

// RbModConstAt calls `rb_mod_const_at` in C
//
// Original definition is following
//
//	void *rb_mod_const_at(VALUE, void*)
func RbModConstAt(arg1 VALUE, arg2 unsafe.Pointer) unsafe.Pointer {
	return unsafe.Pointer(C.rb_mod_const_at(C.VALUE(arg1), arg2))
}

// RbModConstOf calls `rb_mod_const_of` in C
//
// Original definition is following
//
//	void *rb_mod_const_of(VALUE, void*)
func RbModConstOf(arg1 VALUE, arg2 unsafe.Pointer) unsafe.Pointer {
	return unsafe.Pointer(C.rb_mod_const_of(C.VALUE(arg1), arg2))
}

// RbModConstants calls `rb_mod_constants` in C
//
// Original definition is following
//
//	VALUE rb_mod_constants(int argc, const VALUE *argv, VALUE recv)
func RbModConstants(argc int, argv *VALUE, recv VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_mod_constants(C.int(argc), &cArgv, C.VALUE(recv)))
	*argv = VALUE(cArgv)
	return ret
}

// RbModIncludeP calls `rb_mod_include_p` in C
//
// Original definition is following
//
//	VALUE rb_mod_include_p(VALUE child, VALUE parent)
func RbModIncludeP(child VALUE, parent VALUE) VALUE {
	return VALUE(C.rb_mod_include_p(C.VALUE(child), C.VALUE(parent)))
}

// RbModIncludedModules calls `rb_mod_included_modules` in C
//
// Original definition is following
//
//	VALUE rb_mod_included_modules(VALUE mod)
func RbModIncludedModules(mod VALUE) VALUE {
	return VALUE(C.rb_mod_included_modules(C.VALUE(mod)))
}

// RbModInitCopy calls `rb_mod_init_copy` in C
//
// Original definition is following
//
//	VALUE rb_mod_init_copy(VALUE clone, VALUE orig)
func RbModInitCopy(clone VALUE, orig VALUE) VALUE {
	return VALUE(C.rb_mod_init_copy(C.VALUE(clone), C.VALUE(orig)))
}

// RbModMethodArity calls `rb_mod_method_arity` in C
//
// Original definition is following
//
//	int rb_mod_method_arity(VALUE mod, ID mid)
func RbModMethodArity(mod VALUE, mid ID) int {
	return int(C.rb_mod_method_arity(C.VALUE(mod), C.ID(mid)))
}

// RbModModuleEval calls `rb_mod_module_eval` in C
//
// Original definition is following
//
//	VALUE rb_mod_module_eval(int argc, const VALUE *argv, VALUE mod)
func RbModModuleEval(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_mod_module_eval(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbModModuleExec calls `rb_mod_module_exec` in C
//
// Original definition is following
//
//	VALUE rb_mod_module_exec(int argc, const VALUE *argv, VALUE mod)
func RbModModuleExec(argc int, argv *VALUE, mod VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_mod_module_exec(C.int(argc), &cArgv, C.VALUE(mod)))
	*argv = VALUE(cArgv)
	return ret
}

// RbModName calls `rb_mod_name` in C
//
// Original definition is following
//
//	VALUE rb_mod_name(VALUE mod)
func RbModName(mod VALUE) VALUE {
	return VALUE(C.rb_mod_name(C.VALUE(mod)))
}

// RbModRemoveConst calls `rb_mod_remove_const` in C
//
// Original definition is following
//
//	VALUE rb_mod_remove_const(VALUE space, VALUE name)
func RbModRemoveConst(space VALUE, name VALUE) VALUE {
	return VALUE(C.rb_mod_remove_const(C.VALUE(space), C.VALUE(name)))
}

// RbModRemoveCvar calls `rb_mod_remove_cvar` in C
//
// Original definition is following
//
//	VALUE rb_mod_remove_cvar(VALUE mod, VALUE name)
func RbModRemoveCvar(mod VALUE, name VALUE) VALUE {
	return VALUE(C.rb_mod_remove_cvar(C.VALUE(mod), C.VALUE(name)))
}

// RbModSysFail calls `rb_mod_sys_fail` in C
//
// Original definition is following
//
//	void rb_mod_sys_fail(VALUE mod, const char *msg)
func RbModSysFail(mod VALUE, msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_mod_sys_fail(C.VALUE(mod), char)
}

// RbModSysFailStr calls `rb_mod_sys_fail_str` in C
//
// Original definition is following
//
//	void rb_mod_sys_fail_str(VALUE mod, VALUE msg)
func RbModSysFailStr(mod VALUE, msg VALUE) {
	C.rb_mod_sys_fail_str(C.VALUE(mod), C.VALUE(msg))
}

// RbModSyserrFail calls `rb_mod_syserr_fail` in C
//
// Original definition is following
//
//	void rb_mod_syserr_fail(VALUE mod, int err, const char *msg)
func RbModSyserrFail(mod VALUE, err int, msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_mod_syserr_fail(C.VALUE(mod), C.int(err), char)
}

// RbModSyserrFailStr calls `rb_mod_syserr_fail_str` in C
//
// Original definition is following
//
//	void rb_mod_syserr_fail_str(VALUE mod, int err, VALUE msg)
func RbModSyserrFailStr(mod VALUE, err int, msg VALUE) {
	C.rb_mod_syserr_fail_str(C.VALUE(mod), C.int(err), C.VALUE(msg))
}

// RbModuleNew calls `rb_module_new` in C
//
// Original definition is following
//
//	VALUE rb_module_new(void)
func RbModuleNew() VALUE {
	return VALUE(C.rb_module_new())
}

// RbMulSizeOverflow calls `rb_mul_size_overflow` in C
//
// Original definition is following
//
//	rb_mul_size_overflow(size_t a, size_t b, size_t max, size_t *c)
func RbMulSizeOverflow(a SizeT, b SizeT, max SizeT, c *SizeT) int {
	var cC C.size_t
	ret := int(C.rb_mul_size_overflow(C.size_t(a), C.size_t(b), C.size_t(max), &cC))
	*c = SizeT(cC)
	return ret
}

// RbMustAsciicompat calls `rb_must_asciicompat` in C
//
// Original definition is following
//
//	void rb_must_asciicompat(VALUE obj)
func RbMustAsciicompat(obj VALUE) {
	C.rb_must_asciicompat(C.VALUE(obj))
}

// RbMutexLock calls `rb_mutex_lock` in C
//
// Original definition is following
//
//	VALUE rb_mutex_lock(VALUE mutex)
func RbMutexLock(mutex VALUE) VALUE {
	return VALUE(C.rb_mutex_lock(C.VALUE(mutex)))
}

// RbMutexLockedP calls `rb_mutex_locked_p` in C
//
// Original definition is following
//
//	VALUE rb_mutex_locked_p(VALUE mutex)
func RbMutexLockedP(mutex VALUE) VALUE {
	return VALUE(C.rb_mutex_locked_p(C.VALUE(mutex)))
}

// RbMutexNew calls `rb_mutex_new` in C
//
// Original definition is following
//
//	VALUE rb_mutex_new(void)
func RbMutexNew() VALUE {
	return VALUE(C.rb_mutex_new())
}

// RbMutexSleep calls `rb_mutex_sleep` in C
//
// Original definition is following
//
//	VALUE rb_mutex_sleep(VALUE self, VALUE timeout)
func RbMutexSleep(self VALUE, timeout VALUE) VALUE {
	return VALUE(C.rb_mutex_sleep(C.VALUE(self), C.VALUE(timeout)))
}

// RbMutexSynchronize calls `rb_mutex_synchronize` in C
//
// Original definition is following
//
//	VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg)
func RbMutexSynchronize(mutex VALUE, arg2 unsafe.Pointer, arg VALUE) VALUE {
	return VALUE(C.rb_mutex_synchronize(C.VALUE(mutex), toCFunctionPointer(arg2), C.VALUE(arg)))
}

// RbMutexTrylock calls `rb_mutex_trylock` in C
//
// Original definition is following
//
//	VALUE rb_mutex_trylock(VALUE mutex)
func RbMutexTrylock(mutex VALUE) VALUE {
	return VALUE(C.rb_mutex_trylock(C.VALUE(mutex)))
}

// RbMutexUnlock calls `rb_mutex_unlock` in C
//
// Original definition is following
//
//	VALUE rb_mutex_unlock(VALUE mutex)
func RbMutexUnlock(mutex VALUE) VALUE {
	return VALUE(C.rb_mutex_unlock(C.VALUE(mutex)))
}

// RbNeedBlock calls `rb_need_block` in C
//
// Original definition is following
//
//	void rb_need_block(void)
func RbNeedBlock() {
	C.rb_need_block()
}

// RbNewobj calls `rb_newobj` in C
//
// Original definition is following
//
//	VALUE rb_newobj(void)
func RbNewobj() VALUE {
	return VALUE(C.rb_newobj())
}

// RbNewobjOf calls `rb_newobj_of` in C
//
// Original definition is following
//
//	VALUE rb_newobj_of(VALUE klass, VALUE flags)
func RbNewobjOf(klass VALUE, flags VALUE) VALUE {
	return VALUE(C.rb_newobj_of(C.VALUE(klass), C.VALUE(flags)))
}

// RbNotimplement calls `rb_notimplement` in C
//
// Original definition is following
//
//	void rb_notimplement(void)
func RbNotimplement() {
	C.rb_notimplement()
}

// RbNum2CharInline calls `rb_num2char_inline` in C
//
// Original definition is following
//
//	rb_num2char_inline(VALUE x)
func RbNum2CharInline(x VALUE) Char {
	return Char(C.rb_num2char_inline(C.VALUE(x)))
}

// RbNum2Dbl calls `rb_num2dbl` in C
//
// Original definition is following
//
//	double rb_num2dbl(VALUE num)
func RbNum2Dbl(num VALUE) Double {
	return Double(C.rb_num2dbl(C.VALUE(num)))
}

// RbNum2Fix calls `rb_num2fix` in C
//
// Original definition is following
//
//	VALUE rb_num2fix(VALUE val)
func RbNum2Fix(val VALUE) VALUE {
	return VALUE(C.rb_num2fix(C.VALUE(val)))
}

// RbNum2Int calls `rb_num2int` in C
//
// Original definition is following
//
//	long rb_num2int(VALUE num)
func RbNum2Int(num VALUE) Long {
	return Long(C.rb_num2int(C.VALUE(num)))
}

// RbNum2IntInline calls `rb_num2int_inline` in C
//
// Original definition is following
//
//	rb_num2int_inline(VALUE x)
func RbNum2IntInline(x VALUE) int {
	return int(C.rb_num2int_inline(C.VALUE(x)))
}

// RbNum2Ll calls `rb_num2ll` in C
//
// Original definition is following
//
//	rb_num2ll(VALUE num)
func RbNum2Ll(num VALUE) Longlong {
	return Longlong(C.rb_num2ll(C.VALUE(num)))
}

// RbNum2LlInline calls `rb_num2ll_inline` in C
//
// Original definition is following
//
//	rb_num2ll_inline(VALUE x)
func RbNum2LlInline(x VALUE) Longlong {
	return Longlong(C.rb_num2ll_inline(C.VALUE(x)))
}

// RbNum2Long calls `rb_num2long` in C
//
// Original definition is following
//
//	long rb_num2long(VALUE num)
func RbNum2Long(num VALUE) Long {
	return Long(C.rb_num2long(C.VALUE(num)))
}

// RbNum2LongInline calls `rb_num2long_inline` in C
//
// Original definition is following
//
//	rb_num2long_inline(VALUE x)
func RbNum2LongInline(x VALUE) Long {
	return Long(C.rb_num2long_inline(C.VALUE(x)))
}

// RbNum2Short calls `rb_num2short` in C
//
// Original definition is following
//
//	short rb_num2short(VALUE num)
func RbNum2Short(num VALUE) Short {
	return Short(C.rb_num2short(C.VALUE(num)))
}

// RbNum2ShortInline calls `rb_num2short_inline` in C
//
// Original definition is following
//
//	rb_num2short_inline(VALUE x)
func RbNum2ShortInline(x VALUE) Short {
	return Short(C.rb_num2short_inline(C.VALUE(x)))
}

// RbNum2Uint calls `rb_num2uint` in C
//
// Original definition is following
//
//	unsigned long rb_num2uint(VALUE num)
func RbNum2Uint(num VALUE) uint {
	return uint(C.rb_num2uint(C.VALUE(num)))
}

// RbNum2Ull calls `rb_num2ull` in C
//
// Original definition is following
//
//	rb_num2ull(VALUE num)
func RbNum2Ull(num VALUE) Ulonglong {
	return Ulonglong(C.rb_num2ull(C.VALUE(num)))
}

// RbNum2UllInline calls `rb_num2ull_inline` in C
//
// Original definition is following
//
//	rb_num2ull_inline(VALUE x)
func RbNum2UllInline(x VALUE) Ulonglong {
	return Ulonglong(C.rb_num2ull_inline(C.VALUE(x)))
}

// RbNum2Ulong calls `rb_num2ulong` in C
//
// Original definition is following
//
//	unsigned long rb_num2ulong(VALUE num)
func RbNum2Ulong(num VALUE) uint {
	return uint(C.rb_num2ulong(C.VALUE(num)))
}

// RbNum2UlongInline calls `rb_num2ulong_inline` in C
//
// Original definition is following
//
//	rb_num2ulong_inline(VALUE x)
func RbNum2UlongInline(x VALUE) uint {
	return uint(C.rb_num2ulong_inline(C.VALUE(x)))
}

// RbNum2Ushort calls `rb_num2ushort` in C
//
// Original definition is following
//
//	unsigned short rb_num2ushort(VALUE num)
func RbNum2Ushort(num VALUE) Ushort {
	return Ushort(C.rb_num2ushort(C.VALUE(num)))
}

// RbNumCoerceBin calls `rb_num_coerce_bin` in C
//
// Original definition is following
//
//	VALUE rb_num_coerce_bin(VALUE lhs, VALUE rhs, ID op)
func RbNumCoerceBin(lhs VALUE, rhs VALUE, op ID) VALUE {
	return VALUE(C.rb_num_coerce_bin(C.VALUE(lhs), C.VALUE(rhs), C.ID(op)))
}

// RbNumCoerceBit calls `rb_num_coerce_bit` in C
//
// Original definition is following
//
//	VALUE rb_num_coerce_bit(VALUE lhs, VALUE rhs, ID op)
func RbNumCoerceBit(lhs VALUE, rhs VALUE, op ID) VALUE {
	return VALUE(C.rb_num_coerce_bit(C.VALUE(lhs), C.VALUE(rhs), C.ID(op)))
}

// RbNumCoerceCmp calls `rb_num_coerce_cmp` in C
//
// Original definition is following
//
//	VALUE rb_num_coerce_cmp(VALUE lhs, VALUE rhs, ID op)
func RbNumCoerceCmp(lhs VALUE, rhs VALUE, op ID) VALUE {
	return VALUE(C.rb_num_coerce_cmp(C.VALUE(lhs), C.VALUE(rhs), C.ID(op)))
}

// RbNumCoerceRelop calls `rb_num_coerce_relop` in C
//
// Original definition is following
//
//	VALUE rb_num_coerce_relop(VALUE lhs, VALUE rhs, ID op)
func RbNumCoerceRelop(lhs VALUE, rhs VALUE, op ID) VALUE {
	return VALUE(C.rb_num_coerce_relop(C.VALUE(lhs), C.VALUE(rhs), C.ID(op)))
}

// RbNumZerodiv calls `rb_num_zerodiv` in C
//
// Original definition is following
//
//	void rb_num_zerodiv(void)
func RbNumZerodiv() {
	C.rb_num_zerodiv()
}

// RbObjAlloc calls `rb_obj_alloc` in C
//
// Original definition is following
//
//	VALUE rb_obj_alloc(VALUE klass)
func RbObjAlloc(klass VALUE) VALUE {
	return VALUE(C.rb_obj_alloc(C.VALUE(klass)))
}

// RbObjAsString calls `rb_obj_as_string` in C
//
// Original definition is following
//
//	VALUE rb_obj_as_string(VALUE obj)
func RbObjAsString(obj VALUE) VALUE {
	return VALUE(C.rb_obj_as_string(C.VALUE(obj)))
}

// RbObjCallInit calls `rb_obj_call_init` in C
//
// Original definition is following
//
//	void rb_obj_call_init(VALUE obj, int argc, const VALUE *argv)
func RbObjCallInit(obj VALUE, argc int, argv *VALUE) {
	var cArgv C.VALUE
	C.rb_obj_call_init(C.VALUE(obj), C.int(argc), &cArgv)
	*argv = VALUE(cArgv)
}

// RbObjCallInitKw calls `rb_obj_call_init_kw` in C
//
// Original definition is following
//
//	void rb_obj_call_init_kw(VALUE, int, const VALUE*, int)
func RbObjCallInitKw(arg1 VALUE, arg2 int, arg3 *VALUE, arg4 int) {
	var cArg3 C.VALUE
	C.rb_obj_call_init_kw(C.VALUE(arg1), C.int(arg2), &cArg3, C.int(arg4))
	*arg3 = VALUE(cArg3)
}

// RbObjClass calls `rb_obj_class` in C
//
// Original definition is following
//
//	VALUE rb_obj_class(VALUE obj)
func RbObjClass(obj VALUE) VALUE {
	return VALUE(C.rb_obj_class(C.VALUE(obj)))
}

// RbObjClassname calls `rb_obj_classname` in C
//
// Original definition is following
//
//	const char *rb_obj_classname(VALUE obj)
func RbObjClassname(obj VALUE) string {
	return char2String(C.rb_obj_classname(C.VALUE(obj)))
}

// RbObjClone calls `rb_obj_clone` in C
//
// Original definition is following
//
//	VALUE rb_obj_clone(VALUE obj)
func RbObjClone(obj VALUE) VALUE {
	return VALUE(C.rb_obj_clone(C.VALUE(obj)))
}

// RbObjDup calls `rb_obj_dup` in C
//
// Original definition is following
//
//	VALUE rb_obj_dup(VALUE obj)
func RbObjDup(obj VALUE) VALUE {
	return VALUE(C.rb_obj_dup(C.VALUE(obj)))
}

// RbObjFreeze calls `rb_obj_freeze` in C
//
// Original definition is following
//
//	VALUE rb_obj_freeze(VALUE obj)
func RbObjFreeze(obj VALUE) VALUE {
	return VALUE(C.rb_obj_freeze(C.VALUE(obj)))
}

// RbObjFreezeInline calls `rb_obj_freeze_inline` in C
//
// Original definition is following
//
//	void rb_obj_freeze_inline(VALUE obj)
func RbObjFreezeInline(obj VALUE) {
	C.rb_obj_freeze_inline(C.VALUE(obj))
}

// RbObjFrozenP calls `rb_obj_frozen_p` in C
//
// Original definition is following
//
//	VALUE rb_obj_frozen_p(VALUE obj)
func RbObjFrozenP(obj VALUE) VALUE {
	return VALUE(C.rb_obj_frozen_p(C.VALUE(obj)))
}

// RbObjHide calls `rb_obj_hide` in C
//
// Original definition is following
//
//	VALUE rb_obj_hide(VALUE obj)
func RbObjHide(obj VALUE) VALUE {
	return VALUE(C.rb_obj_hide(C.VALUE(obj)))
}

// RbObjId calls `rb_obj_id` in C
//
// Original definition is following
//
//	VALUE rb_obj_id(VALUE obj)
func RbObjId(obj VALUE) VALUE {
	return VALUE(C.rb_obj_id(C.VALUE(obj)))
}

// RbObjInitCopy calls `rb_obj_init_copy` in C
//
// Original definition is following
//
//	VALUE rb_obj_init_copy(VALUE src, VALUE dst)
func RbObjInitCopy(src VALUE, dst VALUE) VALUE {
	return VALUE(C.rb_obj_init_copy(C.VALUE(src), C.VALUE(dst)))
}

// RbObjInstanceEval calls `rb_obj_instance_eval` in C
//
// Original definition is following
//
//	VALUE rb_obj_instance_eval(int argc, const VALUE *argv, VALUE recv)
func RbObjInstanceEval(argc int, argv *VALUE, recv VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_obj_instance_eval(C.int(argc), &cArgv, C.VALUE(recv)))
	*argv = VALUE(cArgv)
	return ret
}

// RbObjInstanceExec calls `rb_obj_instance_exec` in C
//
// Original definition is following
//
//	VALUE rb_obj_instance_exec(int argc, const VALUE *argv, VALUE recv)
func RbObjInstanceExec(argc int, argv *VALUE, recv VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_obj_instance_exec(C.int(argc), &cArgv, C.VALUE(recv)))
	*argv = VALUE(cArgv)
	return ret
}

// RbObjInstanceVariables calls `rb_obj_instance_variables` in C
//
// Original definition is following
//
//	VALUE rb_obj_instance_variables(VALUE obj)
func RbObjInstanceVariables(obj VALUE) VALUE {
	return VALUE(C.rb_obj_instance_variables(C.VALUE(obj)))
}

// RbObjIsFiber calls `rb_obj_is_fiber` in C
//
// Original definition is following
//
//	VALUE rb_obj_is_fiber(VALUE obj)
func RbObjIsFiber(obj VALUE) VALUE {
	return VALUE(C.rb_obj_is_fiber(C.VALUE(obj)))
}

// RbObjIsInstanceOf calls `rb_obj_is_instance_of` in C
//
// Original definition is following
//
//	VALUE rb_obj_is_instance_of(VALUE obj, VALUE klass)
func RbObjIsInstanceOf(obj VALUE, klass VALUE) VALUE {
	return VALUE(C.rb_obj_is_instance_of(C.VALUE(obj), C.VALUE(klass)))
}

// RbObjIsKindOf calls `rb_obj_is_kind_of` in C
//
// Original definition is following
//
//	VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
func RbObjIsKindOf(obj VALUE, klass VALUE) VALUE {
	return VALUE(C.rb_obj_is_kind_of(C.VALUE(obj), C.VALUE(klass)))
}

// RbObjIsMethod calls `rb_obj_is_method` in C
//
// Original definition is following
//
//	VALUE rb_obj_is_method(VALUE recv)
func RbObjIsMethod(recv VALUE) VALUE {
	return VALUE(C.rb_obj_is_method(C.VALUE(recv)))
}

// RbObjIsProc calls `rb_obj_is_proc` in C
//
// Original definition is following
//
//	VALUE rb_obj_is_proc(VALUE recv)
func RbObjIsProc(recv VALUE) VALUE {
	return VALUE(C.rb_obj_is_proc(C.VALUE(recv)))
}

// RbObjMethod calls `rb_obj_method` in C
//
// Original definition is following
//
//	VALUE rb_obj_method(VALUE recv, VALUE mid)
func RbObjMethod(recv VALUE, mid VALUE) VALUE {
	return VALUE(C.rb_obj_method(C.VALUE(recv), C.VALUE(mid)))
}

// RbObjMethodArity calls `rb_obj_method_arity` in C
//
// Original definition is following
//
//	int rb_obj_method_arity(VALUE obj, ID mid)
func RbObjMethodArity(obj VALUE, mid ID) int {
	return int(C.rb_obj_method_arity(C.VALUE(obj), C.ID(mid)))
}

// RbObjRemoveInstanceVariable calls `rb_obj_remove_instance_variable` in C
//
// Original definition is following
//
//	VALUE rb_obj_remove_instance_variable(VALUE obj, VALUE name)
func RbObjRemoveInstanceVariable(obj VALUE, name VALUE) VALUE {
	return VALUE(C.rb_obj_remove_instance_variable(C.VALUE(obj), C.VALUE(name)))
}

// RbObjRespondTo calls `rb_obj_respond_to` in C
//
// Original definition is following
//
//	int rb_obj_respond_to(VALUE obj, ID mid, int private_p)
func RbObjRespondTo(obj VALUE, mid ID, private_p int) int {
	return int(C.rb_obj_respond_to(C.VALUE(obj), C.ID(mid), C.int(private_p)))
}

// RbObjReveal calls `rb_obj_reveal` in C
//
// Original definition is following
//
//	VALUE rb_obj_reveal(VALUE obj, VALUE klass)
func RbObjReveal(obj VALUE, klass VALUE) VALUE {
	return VALUE(C.rb_obj_reveal(C.VALUE(obj), C.VALUE(klass)))
}

// RbObjSetup calls `rb_obj_setup` in C
//
// Original definition is following
//
//	VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type)
func RbObjSetup(obj VALUE, klass VALUE, t VALUE) VALUE {
	return VALUE(C.rb_obj_setup(C.VALUE(obj), C.VALUE(klass), C.VALUE(t)))
}

// RbObjSingletonMethods calls `rb_obj_singleton_methods` in C
//
// Original definition is following
//
//	VALUE rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
func RbObjSingletonMethods(argc int, argv *VALUE, obj VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_obj_singleton_methods(C.int(argc), &cArgv, C.VALUE(obj)))
	*argv = VALUE(cArgv)
	return ret
}

// RbObjWbUnprotect calls `rb_obj_wb_unprotect` in C
//
// Original definition is following
//
//	rb_obj_wb_unprotect(
func RbObjWbUnprotect(x VALUE, filename string, line int) VALUE {
	char, clean := string2Char(filename)
	defer clean()

	return VALUE(C.rb_obj_wb_unprotect(C.VALUE(x), char, C.int(line)))
}

// RbObjWrite calls `rb_obj_write` in C
//
// Original definition is following
//
//	rb_obj_write(
func RbObjWrite(a VALUE, slot *VALUE, b VALUE, filename string, line int) VALUE {
	var cSlot C.VALUE
	char, clean := string2Char(filename)
	defer clean()

	ret := VALUE(C.rb_obj_write(C.VALUE(a), &cSlot, C.VALUE(b), char, C.int(line)))
	*slot = VALUE(cSlot)
	return ret
}

// RbObjWritten calls `rb_obj_written` in C
//
// Original definition is following
//
//	rb_obj_written(
func RbObjWritten(a VALUE, oldv VALUE, b VALUE, filename string, line int) VALUE {
	char, clean := string2Char(filename)
	defer clean()

	return VALUE(C.rb_obj_written(C.VALUE(a), C.VALUE(oldv), C.VALUE(b), char, C.int(line)))
}

// RbOrigErrnoPtr calls `rb_orig_errno_ptr` in C
//
// Original definition is following
//
//	rb_orig_errno_ptr(void)
func RbOrigErrnoPtr() *Int {
	return (*Int)(C.rb_orig_errno_ptr())
}

// RbOutOfInt calls `rb_out_of_int` in C
//
// Original definition is following
//
//	void rb_out_of_int(long num)
func RbOutOfInt(num Long) {
	C.rb_out_of_int(C.long(num))
}

// RbP calls `rb_p` in C
//
// Original definition is following
//
//	void rb_p(VALUE obj)
func RbP(obj VALUE) {
	C.rb_p(C.VALUE(obj))
}

// RbPath2Class calls `rb_path2class` in C
//
// Original definition is following
//
//	VALUE rb_path2class(const char *path)
func RbPath2Class(path string) VALUE {
	char, clean := string2Char(path)
	defer clean()

	return VALUE(C.rb_path2class(char))
}

// RbPathCheck calls `rb_path_check` in C
//
// Original definition is following
//
//	int rb_path_check(const char *path)
func RbPathCheck(path string) int {
	char, clean := string2Char(path)
	defer clean()

	return int(C.rb_path_check(char))
}

// RbPathToClass calls `rb_path_to_class` in C
//
// Original definition is following
//
//	VALUE rb_path_to_class(VALUE path)
func RbPathToClass(path VALUE) VALUE {
	return VALUE(C.rb_path_to_class(C.VALUE(path)))
}

// RbPipe calls `rb_pipe` in C
//
// Original definition is following
//
//	int rb_pipe(int *pipes)
func RbPipe(pipes *int) int {
	var cPipes C.int
	ret := int(C.rb_pipe(&cPipes))
	*pipes = int(cPipes)
	return ret
}

// RbPrependModule calls `rb_prepend_module` in C
//
// Original definition is following
//
//	void rb_prepend_module(VALUE klass, VALUE module)
func RbPrependModule(klass VALUE, module VALUE) {
	C.rb_prepend_module(C.VALUE(klass), C.VALUE(module))
}

// RbProcArity calls `rb_proc_arity` in C
//
// Original definition is following
//
//	int rb_proc_arity(VALUE recv)
func RbProcArity(recv VALUE) int {
	return int(C.rb_proc_arity(C.VALUE(recv)))
}

// RbProcCall calls `rb_proc_call` in C
//
// Original definition is following
//
//	VALUE rb_proc_call(VALUE recv, VALUE args)
func RbProcCall(recv VALUE, args VALUE) VALUE {
	return VALUE(C.rb_proc_call(C.VALUE(recv), C.VALUE(args)))
}

// RbProcCallKw calls `rb_proc_call_kw` in C
//
// Original definition is following
//
//	VALUE rb_proc_call_kw(VALUE recv, VALUE args, int kw_splat)
func RbProcCallKw(recv VALUE, args VALUE, kw_splat int) VALUE {
	return VALUE(C.rb_proc_call_kw(C.VALUE(recv), C.VALUE(args), C.int(kw_splat)))
}

// RbProcCallWithBlock calls `rb_proc_call_with_block` in C
//
// Original definition is following
//
//	VALUE rb_proc_call_with_block(VALUE recv, int argc, const VALUE *argv, VALUE proc)
func RbProcCallWithBlock(recv VALUE, argc int, argv *VALUE, proc VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_proc_call_with_block(C.VALUE(recv), C.int(argc), &cArgv, C.VALUE(proc)))
	*argv = VALUE(cArgv)
	return ret
}

// RbProcCallWithBlockKw calls `rb_proc_call_with_block_kw` in C
//
// Original definition is following
//
//	VALUE rb_proc_call_with_block_kw(VALUE recv, int argc, const VALUE *argv, VALUE proc, int kw_splat)
func RbProcCallWithBlockKw(recv VALUE, argc int, argv *VALUE, proc VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_proc_call_with_block_kw(C.VALUE(recv), C.int(argc), &cArgv, C.VALUE(proc), C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}

// RbProcExec calls `rb_proc_exec` in C
//
// Original definition is following
//
//	int rb_proc_exec(const char *cmd)
func RbProcExec(cmd string) int {
	char, clean := string2Char(cmd)
	defer clean()

	return int(C.rb_proc_exec(char))
}

// RbProcLambdaP calls `rb_proc_lambda_p` in C
//
// Original definition is following
//
//	VALUE rb_proc_lambda_p(VALUE recv)
func RbProcLambdaP(recv VALUE) VALUE {
	return VALUE(C.rb_proc_lambda_p(C.VALUE(recv)))
}

// RbProcNew calls `rb_proc_new` in C
//
// Original definition is following
//
//	VALUE rb_proc_new(rb_block_call_func_t func, VALUE callback_arg)
func RbProcNew(fun RbBlockCallFuncT, callback_arg VALUE) VALUE {
	return VALUE(C.rb_proc_new(C.rb_block_call_func_t(fun), C.VALUE(callback_arg)))
}

// RbProcTimes calls `rb_proc_times` in C
//
// Original definition is following
//
//	VALUE rb_proc_times(VALUE _)
func RbProcTimes(arg VALUE) VALUE {
	return VALUE(C.rb_proc_times(C.VALUE(arg)))
}

// RbProcessStatusWait calls `rb_process_status_wait` in C
//
// Original definition is following
//
//	VALUE rb_process_status_wait(pid_t pid, int flags)
func RbProcessStatusWait(pid PidT, flags int) VALUE {
	return VALUE(C.rb_process_status_wait(C.pid_t(pid), C.int(flags)))
}

// RbProtect calls `rb_protect` in C
//
// Original definition is following
//
//	VALUE rb_protect(VALUE (*func)(VALUE args), VALUE args, int *state)
func RbProtect(arg1 unsafe.Pointer, args VALUE, state *int) VALUE {
	var cState C.int
	ret := VALUE(C.rb_protect(toCFunctionPointer(arg1), C.VALUE(args), &cState))
	*state = int(cState)
	return ret
}

// RbProvide calls `rb_provide` in C
//
// Original definition is following
//
//	void rb_provide(const char *feature)
func RbProvide(feature string) {
	char, clean := string2Char(feature)
	defer clean()

	C.rb_provide(char)
}

// RbProvided calls `rb_provided` in C
//
// Original definition is following
//
//	int rb_provided(const char *feature)
func RbProvided(feature string) int {
	char, clean := string2Char(feature)
	defer clean()

	return int(C.rb_provided(char))
}

// RbRandomBytes calls `rb_random_bytes` in C
//
// Original definition is following
//
//	VALUE rb_random_bytes(VALUE rnd, long n)
func RbRandomBytes(rnd VALUE, n Long) VALUE {
	return VALUE(C.rb_random_bytes(C.VALUE(rnd), C.long(n)))
}

// RbRandomInt32 calls `rb_random_int32` in C
//
// Original definition is following
//
//	unsigned int rb_random_int32(VALUE rnd)
func RbRandomInt32(rnd VALUE) uint {
	return uint(C.rb_random_int32(C.VALUE(rnd)))
}

// RbRandomReal calls `rb_random_real` in C
//
// Original definition is following
//
//	double rb_random_real(VALUE rnd)
func RbRandomReal(rnd VALUE) Double {
	return Double(C.rb_random_real(C.VALUE(rnd)))
}

// RbRandomUlongLimited calls `rb_random_ulong_limited` in C
//
// Original definition is following
//
//	unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit)
func RbRandomUlongLimited(rnd VALUE, limit uint) uint {
	return uint(C.rb_random_ulong_limited(C.VALUE(rnd), C.ulong(limit)))
}

// RbRangeBegLen calls `rb_range_beg_len` in C
//
// Original definition is following
//
//	VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err)
func RbRangeBegLen(r VALUE, begp *Long, lenp *Long, len Long, err int) VALUE {
	var cBegp C.long
	var cLenp C.long
	ret := VALUE(C.rb_range_beg_len(C.VALUE(r), &cBegp, &cLenp, C.long(len), C.int(err)))
	*begp = Long(cBegp)
	*lenp = Long(cLenp)
	return ret
}

// RbRangeNew calls `rb_range_new` in C
//
// Original definition is following
//
//	VALUE rb_range_new(VALUE beg, VALUE end, int excl)
func RbRangeNew(beg VALUE, end VALUE, excl int) VALUE {
	return VALUE(C.rb_range_new(C.VALUE(beg), C.VALUE(end), C.int(excl)))
}

// RbRangeValues calls `rb_range_values` in C
//
// Original definition is following
//
//	int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
func RbRangeValues(r VALUE, begp *VALUE, endp *VALUE, exclp *int) int {
	var cBegp C.VALUE
	var cEndp C.VALUE
	var cExclp C.int
	ret := int(C.rb_range_values(C.VALUE(r), &cBegp, &cEndp, &cExclp))
	*begp = VALUE(cBegp)
	*endp = VALUE(cEndp)
	*exclp = int(cExclp)
	return ret
}

// RbRationalDen calls `rb_rational_den` in C
//
// Original definition is following
//
//	VALUE rb_rational_den(VALUE rat)
func RbRationalDen(rat VALUE) VALUE {
	return VALUE(C.rb_rational_den(C.VALUE(rat)))
}

// RbRationalNew calls `rb_rational_new` in C
//
// Original definition is following
//
//	VALUE rb_rational_new(VALUE num, VALUE den)
func RbRationalNew(num VALUE, den VALUE) VALUE {
	return VALUE(C.rb_rational_new(C.VALUE(num), C.VALUE(den)))
}

// RbRationalNum calls `rb_rational_num` in C
//
// Original definition is following
//
//	VALUE rb_rational_num(VALUE rat)
func RbRationalNum(rat VALUE) VALUE {
	return VALUE(C.rb_rational_num(C.VALUE(rat)))
}

// RbRationalRaw calls `rb_rational_raw` in C
//
// Original definition is following
//
//	VALUE rb_rational_raw(VALUE num, VALUE den)
func RbRationalRaw(num VALUE, den VALUE) VALUE {
	return VALUE(C.rb_rational_raw(C.VALUE(num), C.VALUE(den)))
}

// RbReadwriteSysFail calls `rb_readwrite_sys_fail` in C
//
// Original definition is following
//
//	void rb_readwrite_sys_fail(enum rb_io_wait_readwrite waiting, const char *msg)
func RbReadwriteSysFail(waiting RbIoWaitReadwrite, msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_readwrite_sys_fail(C.enum_rb_io_wait_readwrite(waiting), char)
}

// RbReadwriteSyserrFail calls `rb_readwrite_syserr_fail` in C
//
// Original definition is following
//
//	void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite waiting, int err, const char *msg)
func RbReadwriteSyserrFail(waiting RbIoWaitReadwrite, err int, msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_readwrite_syserr_fail(C.enum_rb_io_wait_readwrite(waiting), C.int(err), char)
}

// RbRefinementNew calls `rb_refinement_new` in C
//
// Original definition is following
//
//	VALUE rb_refinement_new(void)
func RbRefinementNew() VALUE {
	return VALUE(C.rb_refinement_new())
}

// RbRegAlloc calls `rb_reg_alloc` in C
//
// Original definition is following
//
//	VALUE rb_reg_alloc(void)
func RbRegAlloc() VALUE {
	return VALUE(C.rb_reg_alloc())
}

// RbRegBackrefNumber calls `rb_reg_backref_number` in C
//
// Original definition is following
//
//	int rb_reg_backref_number(VALUE match, VALUE backref)
func RbRegBackrefNumber(match VALUE, backref VALUE) int {
	return int(C.rb_reg_backref_number(C.VALUE(match), C.VALUE(backref)))
}

// RbRegInitStr calls `rb_reg_init_str` in C
//
// Original definition is following
//
//	VALUE rb_reg_init_str(VALUE re, VALUE s, int options)
func RbRegInitStr(re VALUE, s VALUE, options int) VALUE {
	return VALUE(C.rb_reg_init_str(C.VALUE(re), C.VALUE(s), C.int(options)))
}

// RbRegLastMatch calls `rb_reg_last_match` in C
//
// Original definition is following
//
//	VALUE rb_reg_last_match(VALUE md)
func RbRegLastMatch(md VALUE) VALUE {
	return VALUE(C.rb_reg_last_match(C.VALUE(md)))
}

// RbRegMatch calls `rb_reg_match` in C
//
// Original definition is following
//
//	VALUE rb_reg_match(VALUE re, VALUE str)
func RbRegMatch(re VALUE, str VALUE) VALUE {
	return VALUE(C.rb_reg_match(C.VALUE(re), C.VALUE(str)))
}

// RbRegMatch2 calls `rb_reg_match2` in C
//
// Original definition is following
//
//	VALUE rb_reg_match2(VALUE re)
func RbRegMatch2(re VALUE) VALUE {
	return VALUE(C.rb_reg_match2(C.VALUE(re)))
}

// RbRegMatchLast calls `rb_reg_match_last` in C
//
// Original definition is following
//
//	VALUE rb_reg_match_last(VALUE md)
func RbRegMatchLast(md VALUE) VALUE {
	return VALUE(C.rb_reg_match_last(C.VALUE(md)))
}

// RbRegMatchPost calls `rb_reg_match_post` in C
//
// Original definition is following
//
//	VALUE rb_reg_match_post(VALUE md)
func RbRegMatchPost(md VALUE) VALUE {
	return VALUE(C.rb_reg_match_post(C.VALUE(md)))
}

// RbRegMatchPre calls `rb_reg_match_pre` in C
//
// Original definition is following
//
//	VALUE rb_reg_match_pre(VALUE md)
func RbRegMatchPre(md VALUE) VALUE {
	return VALUE(C.rb_reg_match_pre(C.VALUE(md)))
}

// RbRegNew calls `rb_reg_new` in C
//
// Original definition is following
//
//	VALUE rb_reg_new(const char *src, long len, int opts)
func RbRegNew(src string, len Long, opts int) VALUE {
	char, clean := string2Char(src)
	defer clean()

	return VALUE(C.rb_reg_new(char, C.long(len), C.int(opts)))
}

// RbRegNewStr calls `rb_reg_new_str` in C
//
// Original definition is following
//
//	VALUE rb_reg_new_str(VALUE src, int opts)
func RbRegNewStr(src VALUE, opts int) VALUE {
	return VALUE(C.rb_reg_new_str(C.VALUE(src), C.int(opts)))
}

// RbRegNthDefined calls `rb_reg_nth_defined` in C
//
// Original definition is following
//
//	VALUE rb_reg_nth_defined(int n, VALUE md)
func RbRegNthDefined(n int, md VALUE) VALUE {
	return VALUE(C.rb_reg_nth_defined(C.int(n), C.VALUE(md)))
}

// RbRegNthMatch calls `rb_reg_nth_match` in C
//
// Original definition is following
//
//	VALUE rb_reg_nth_match(int n, VALUE md)
func RbRegNthMatch(n int, md VALUE) VALUE {
	return VALUE(C.rb_reg_nth_match(C.int(n), C.VALUE(md)))
}

// RbRegOptions calls `rb_reg_options` in C
//
// Original definition is following
//
//	int rb_reg_options(VALUE re)
func RbRegOptions(re VALUE) int {
	return int(C.rb_reg_options(C.VALUE(re)))
}

// RbRemoveEventHook calls `rb_remove_event_hook` in C
//
// Original definition is following
//
//	int rb_remove_event_hook(rb_event_hook_func_t func)
func RbRemoveEventHook(fun RbEventHookFuncT) int {
	return int(C.rb_remove_event_hook(C.rb_event_hook_func_t(fun)))
}

// RbRemoveMethod calls `rb_remove_method` in C
//
// Original definition is following
//
//	void rb_remove_method(VALUE klass, const char *name)
func RbRemoveMethod(klass VALUE, name string) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_remove_method(C.VALUE(klass), char)
}

// RbRemoveMethodId calls `rb_remove_method_id` in C
//
// Original definition is following
//
//	void rb_remove_method_id(VALUE klass, ID mid)
func RbRemoveMethodId(klass VALUE, mid ID) {
	C.rb_remove_method_id(C.VALUE(klass), C.ID(mid))
}

// RbRequire calls `rb_require` in C
//
// Original definition is following
//
//	VALUE rb_require(const char *feature)
func RbRequire(feature string) VALUE {
	char, clean := string2Char(feature)
	defer clean()

	return VALUE(C.rb_require(char))
}

// RbRequireString calls `rb_require_string` in C
//
// Original definition is following
//
//	VALUE rb_require_string(VALUE feature)
func RbRequireString(feature VALUE) VALUE {
	return VALUE(C.rb_require_string(C.VALUE(feature)))
}

// RbRescue calls `rb_rescue` in C
//
// Original definition is following
//
//	VALUE rb_rescue(VALUE (*b_proc)(VALUE), VALUE data1, VALUE (*r_proc)(VALUE, VALUE), VALUE data2)
func RbRescue(arg1 unsafe.Pointer, data1 VALUE, arg3 unsafe.Pointer, data2 VALUE) VALUE {
	return VALUE(C.rb_rescue(toCFunctionPointer(arg1), C.VALUE(data1), toCFunctionPointer(arg3), C.VALUE(data2)))
}

// RbReservedFdP calls `rb_reserved_fd_p` in C
//
// Original definition is following
//
//	int rb_reserved_fd_p(int fd)
func RbReservedFdP(fd int) int {
	return int(C.rb_reserved_fd_p(C.int(fd)))
}

// RbResetRandomSeed calls `rb_reset_random_seed` in C
//
// Original definition is following
//
//	void rb_reset_random_seed(void)
func RbResetRandomSeed() {
	C.rb_reset_random_seed()
}

// RbRespondTo calls `rb_respond_to` in C
//
// Original definition is following
//
//	int rb_respond_to(VALUE obj, ID mid)
func RbRespondTo(obj VALUE, mid ID) int {
	return int(C.rb_respond_to(C.VALUE(obj), C.ID(mid)))
}

// RbRubyDebugPtr calls `rb_ruby_debug_ptr` in C
//
// Original definition is following
//
//	VALUE *rb_ruby_debug_ptr(void)
func RbRubyDebugPtr() *VALUE {
	return (*VALUE)(C.rb_ruby_debug_ptr())
}

// RbRubyVerbosePtr calls `rb_ruby_verbose_ptr` in C
//
// Original definition is following
//
//	VALUE *rb_ruby_verbose_ptr(void)
func RbRubyVerbosePtr() *VALUE {
	return (*VALUE)(C.rb_ruby_verbose_ptr())
}

// RbScanArgsBlockIdx calls `rb_scan_args_block_idx` in C
//
// Original definition is following
//
//	rb_scan_args_block_idx(const char *fmt)
func RbScanArgsBlockIdx(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_block_idx(char))
}

// RbScanArgsFBlock calls `rb_scan_args_f_block` in C
//
// Original definition is following
//
//	rb_scan_args_f_block(const char *fmt)
func RbScanArgsFBlock(fmt string) Bool {
	char, clean := string2Char(fmt)
	defer clean()

	return Bool(C.rb_scan_args_f_block(char))
}

// RbScanArgsFHash calls `rb_scan_args_f_hash` in C
//
// Original definition is following
//
//	rb_scan_args_f_hash(const char *fmt)
func RbScanArgsFHash(fmt string) Bool {
	char, clean := string2Char(fmt)
	defer clean()

	return Bool(C.rb_scan_args_f_hash(char))
}

// RbScanArgsFVar calls `rb_scan_args_f_var` in C
//
// Original definition is following
//
//	rb_scan_args_f_var(const char *fmt)
func RbScanArgsFVar(fmt string) Bool {
	char, clean := string2Char(fmt)
	defer clean()

	return Bool(C.rb_scan_args_f_var(char))
}

// RbScanArgsHashIdx calls `rb_scan_args_hash_idx` in C
//
// Original definition is following
//
//	rb_scan_args_hash_idx(const char *fmt)
func RbScanArgsHashIdx(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_hash_idx(char))
}

// RbScanArgsKeywordP calls `rb_scan_args_keyword_p` in C
//
// Original definition is following
//
//	rb_scan_args_keyword_p(int kw_flag, VALUE last)
func RbScanArgsKeywordP(kw_flag int, last VALUE) Bool {
	return Bool(C.rb_scan_args_keyword_p(C.int(kw_flag), C.VALUE(last)))
}

// RbScanArgsLeadP calls `rb_scan_args_lead_p` in C
//
// Original definition is following
//
//	rb_scan_args_lead_p(const char *fmt)
func RbScanArgsLeadP(fmt string) Bool {
	char, clean := string2Char(fmt)
	defer clean()

	return Bool(C.rb_scan_args_lead_p(char))
}

// RbScanArgsNLead calls `rb_scan_args_n_lead` in C
//
// Original definition is following
//
//	rb_scan_args_n_lead(const char *fmt)
func RbScanArgsNLead(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_n_lead(char))
}

// RbScanArgsNOpt calls `rb_scan_args_n_opt` in C
//
// Original definition is following
//
//	rb_scan_args_n_opt(const char *fmt)
func RbScanArgsNOpt(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_n_opt(char))
}

// RbScanArgsNTrail calls `rb_scan_args_n_trail` in C
//
// Original definition is following
//
//	rb_scan_args_n_trail(const char *fmt)
func RbScanArgsNTrail(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_n_trail(char))
}

// RbScanArgsOptP calls `rb_scan_args_opt_p` in C
//
// Original definition is following
//
//	rb_scan_args_opt_p(const char *fmt)
func RbScanArgsOptP(fmt string) Bool {
	char, clean := string2Char(fmt)
	defer clean()

	return Bool(C.rb_scan_args_opt_p(char))
}

// RbScanArgsSet calls `rb_scan_args_set` in C
//
// Original definition is following
//
//	rb_scan_args_set(int kw_flag, int argc, const VALUE *argv,
func RbScanArgsSet(kw_flag int, argc int, argv *VALUE, n_lead int, n_opt int, n_trail int, f_var Bool, f_hash Bool, f_block Bool, vars []*VALUE, fmt string, varc int) int {
	var cArgv C.VALUE
	char, clean := string2Char(fmt)
	defer clean()

	ret := int(C.rb_scan_args_set(C.int(kw_flag), C.int(argc), &cArgv, C.int(n_lead), C.int(n_opt), C.int(n_trail), C._Bool(f_var), C._Bool(f_hash), C._Bool(f_block), toCArray[*VALUE, *C.VALUE](vars), char, C.int(varc)))
	*argv = VALUE(cArgv)
	return ret
}

// RbScanArgsTrailIdx calls `rb_scan_args_trail_idx` in C
//
// Original definition is following
//
//	rb_scan_args_trail_idx(const char *fmt)
func RbScanArgsTrailIdx(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_trail_idx(char))
}

// RbScanArgsVarIdx calls `rb_scan_args_var_idx` in C
//
// Original definition is following
//
//	rb_scan_args_var_idx(const char *fmt)
func RbScanArgsVarIdx(fmt string) int {
	char, clean := string2Char(fmt)
	defer clean()

	return int(C.rb_scan_args_var_idx(char))
}

// RbSetClassPath calls `rb_set_class_path` in C
//
// Original definition is following
//
//	void rb_set_class_path(VALUE klass, VALUE space, const char *name)
func RbSetClassPath(klass VALUE, space VALUE, name string) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_set_class_path(C.VALUE(klass), C.VALUE(space), char)
}

// RbSetClassPathString calls `rb_set_class_path_string` in C
//
// Original definition is following
//
//	void rb_set_class_path_string(VALUE klass, VALUE space, VALUE name)
func RbSetClassPathString(klass VALUE, space VALUE, name VALUE) {
	C.rb_set_class_path_string(C.VALUE(klass), C.VALUE(space), C.VALUE(name))
}

// RbSetEndProc calls `rb_set_end_proc` in C
//
// Original definition is following
//
//	void rb_set_end_proc(void (*func)(VALUE arg), VALUE arg)
func RbSetEndProc(arg1 unsafe.Pointer, arg VALUE) {
	C.rb_set_end_proc(toCFunctionPointer(arg1), C.VALUE(arg))
}

// RbSetErrinfo calls `rb_set_errinfo` in C
//
// Original definition is following
//
//	void rb_set_errinfo(VALUE err)
func RbSetErrinfo(err VALUE) {
	C.rb_set_errinfo(C.VALUE(err))
}

// RbSingletonClass calls `rb_singleton_class` in C
//
// Original definition is following
//
//	VALUE rb_singleton_class(VALUE obj)
func RbSingletonClass(obj VALUE) VALUE {
	return VALUE(C.rb_singleton_class(C.VALUE(obj)))
}

// RbSingletonClassAttached calls `rb_singleton_class_attached` in C
//
// Original definition is following
//
//	void rb_singleton_class_attached(VALUE klass, VALUE obj)
func RbSingletonClassAttached(klass VALUE, obj VALUE) {
	C.rb_singleton_class_attached(C.VALUE(klass), C.VALUE(obj))
}

// RbSingletonClassClone calls `rb_singleton_class_clone` in C
//
// Original definition is following
//
//	VALUE rb_singleton_class_clone(VALUE obj)
func RbSingletonClassClone(obj VALUE) VALUE {
	return VALUE(C.rb_singleton_class_clone(C.VALUE(obj)))
}

// RbSourcefile calls `rb_sourcefile` in C
//
// Original definition is following
//
//	const char *rb_sourcefile(void)
func RbSourcefile() string {
	return char2String(C.rb_sourcefile())
}

// RbSourceline calls `rb_sourceline` in C
//
// Original definition is following
//
//	int rb_sourceline(void)
func RbSourceline() int {
	return int(C.rb_sourceline())
}

// RbSpawn calls `rb_spawn` in C
//
// Original definition is following
//
//	pid_t rb_spawn(int argc, const VALUE *argv)
func RbSpawn(argc int, argv *VALUE) PidT {
	var cArgv C.VALUE
	ret := PidT(C.rb_spawn(C.int(argc), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbSpawnErr calls `rb_spawn_err` in C
//
// Original definition is following
//
//	pid_t rb_spawn_err(int argc, const VALUE *argv, char *errbuf, size_t buflen)
func RbSpawnErr(argc int, argv *VALUE, errbuf string, buflen SizeT) PidT {
	var cArgv C.VALUE
	char, clean := string2Char(errbuf)
	defer clean()

	ret := PidT(C.rb_spawn_err(C.int(argc), &cArgv, char, C.size_t(buflen)))
	*argv = VALUE(cArgv)
	return ret
}

// RbSpecialConstP calls `rb_special_const_p` in C
//
// Original definition is following
//
//	rb_special_const_p(VALUE obj)
func RbSpecialConstP(obj VALUE) VALUE {
	return VALUE(C.rb_special_const_p(C.VALUE(obj)))
}

// RbStAddDirect calls `rb_st_add_direct` in C
//
// Original definition is following
//
//	void rb_st_add_direct(st_table *, st_data_t, st_data_t)
func RbStAddDirect(arg1 *StTable, arg2 StDataT, arg3 StDataT) {
	var cArg1 C.st_table
	C.rb_st_add_direct(&cArg1, C.st_data_t(arg2), C.st_data_t(arg3))
	*arg1 = StTable(cArg1)
}

// RbStCleanupSafe calls `rb_st_cleanup_safe` in C
//
// Original definition is following
//
//	void rb_st_cleanup_safe(st_table *, st_data_t)
func RbStCleanupSafe(arg1 *StTable, arg2 StDataT) {
	var cArg1 C.st_table
	C.rb_st_cleanup_safe(&cArg1, C.st_data_t(arg2))
	*arg1 = StTable(cArg1)
}

// RbStClear calls `rb_st_clear` in C
//
// Original definition is following
//
//	void rb_st_clear(st_table *)
func RbStClear(arg1 *StTable) {
	var cArg1 C.st_table
	C.rb_st_clear(&cArg1)
	*arg1 = StTable(cArg1)
}

// RbStCopy calls `rb_st_copy` in C
//
// Original definition is following
//
//	st_table *rb_st_copy(st_table *)
func RbStCopy(arg1 *StTable) *StTable {
	var cArg1 C.st_table
	ret := (*StTable)(C.rb_st_copy(&cArg1))
	*arg1 = StTable(cArg1)
	return ret
}

// RbStDelete calls `rb_st_delete` in C
//
// Original definition is following
//
//	int rb_st_delete(st_table *, st_data_t *, st_data_t *)
func RbStDelete(arg1 *StTable, arg2 *StDataT, arg3 *StDataT) int {
	var cArg1 C.st_table
	var cArg2 C.st_data_t
	var cArg3 C.st_data_t
	ret := int(C.rb_st_delete(&cArg1, &cArg2, &cArg3))
	*arg1 = StTable(cArg1)
	*arg2 = StDataT(cArg2)
	*arg3 = StDataT(cArg3)
	return ret
}

// RbStDeleteSafe calls `rb_st_delete_safe` in C
//
// Original definition is following
//
//	int rb_st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t)
func RbStDeleteSafe(arg1 *StTable, arg2 *StDataT, arg3 *StDataT, arg4 StDataT) int {
	var cArg1 C.st_table
	var cArg2 C.st_data_t
	var cArg3 C.st_data_t
	ret := int(C.rb_st_delete_safe(&cArg1, &cArg2, &cArg3, C.st_data_t(arg4)))
	*arg1 = StTable(cArg1)
	*arg2 = StDataT(cArg2)
	*arg3 = StDataT(cArg3)
	return ret
}

// RbStForeach calls `rb_st_foreach` in C
//
// Original definition is following
//
//	int rb_st_foreach(st_table *, st_foreach_callback_func *, st_data_t)
func RbStForeach(arg1 *StTable, arg2 *StForeachCallbackFunc, arg3 StDataT) int {
	var cArg1 C.st_table
	var cArg2 C.st_foreach_callback_func
	ret := int(C.rb_st_foreach(&cArg1, &cArg2, C.st_data_t(arg3)))
	*arg1 = StTable(cArg1)
	*arg2 = StForeachCallbackFunc(cArg2)
	return ret
}

// RbStForeachCheck calls `rb_st_foreach_check` in C
//
// Original definition is following
//
//	int rb_st_foreach_check(st_table *, st_foreach_check_callback_func *, st_data_t, st_data_t)
func RbStForeachCheck(arg1 *StTable, arg2 *StForeachCheckCallbackFunc, arg3 StDataT, arg4 StDataT) int {
	var cArg1 C.st_table
	var cArg2 C.st_foreach_check_callback_func
	ret := int(C.rb_st_foreach_check(&cArg1, &cArg2, C.st_data_t(arg3), C.st_data_t(arg4)))
	*arg1 = StTable(cArg1)
	*arg2 = StForeachCheckCallbackFunc(cArg2)
	return ret
}

// RbStForeachSafe calls `rb_st_foreach_safe` in C
//
// Original definition is following
//
//	void rb_st_foreach_safe(struct st_table *st, st_foreach_callback_func *func, st_data_t arg)
func RbStForeachSafe(st *StTable, fun *StForeachCallbackFunc, arg StDataT) {
	var cSt C.st_table
	var cFun C.st_foreach_callback_func
	C.rb_st_foreach_safe(&cSt, &cFun, C.st_data_t(arg))
	*st = StTable(cSt)
	*fun = StForeachCallbackFunc(cFun)
}

// RbStForeachWithReplace calls `rb_st_foreach_with_replace` in C
//
// Original definition is following
//
//	int rb_st_foreach_with_replace(st_table *tab, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg)
func RbStForeachWithReplace(tab *StTable, fun *StForeachCheckCallbackFunc, replace *StUpdateCallbackFunc, arg StDataT) int {
	var cTab C.st_table
	var cFun C.st_foreach_check_callback_func
	var cReplace C.st_update_callback_func
	ret := int(C.rb_st_foreach_with_replace(&cTab, &cFun, &cReplace, C.st_data_t(arg)))
	*tab = StTable(cTab)
	*fun = StForeachCheckCallbackFunc(cFun)
	*replace = StUpdateCallbackFunc(cReplace)
	return ret
}

// RbStFreeTable calls `rb_st_free_table` in C
//
// Original definition is following
//
//	void rb_st_free_table(st_table *)
func RbStFreeTable(arg1 *StTable) {
	var cArg1 C.st_table
	C.rb_st_free_table(&cArg1)
	*arg1 = StTable(cArg1)
}

// RbStGetKey calls `rb_st_get_key` in C
//
// Original definition is following
//
//	int rb_st_get_key(st_table *, st_data_t, st_data_t *)
func RbStGetKey(arg1 *StTable, arg2 StDataT, arg3 *StDataT) int {
	var cArg1 C.st_table
	var cArg3 C.st_data_t
	ret := int(C.rb_st_get_key(&cArg1, C.st_data_t(arg2), &cArg3))
	*arg1 = StTable(cArg1)
	*arg3 = StDataT(cArg3)
	return ret
}

// RbStHash calls `rb_st_hash` in C
//
// Original definition is following
//
//	__attribute__((__pure__)) st_index_t rb_st_hash(const void *ptr, size_t len, st_index_t h)
func RbStHash(ptr unsafe.Pointer, len SizeT, h StIndexT) StIndexT {
	return StIndexT(C.rb_st_hash(ptr, C.size_t(len), C.st_index_t(h)))
}

// RbStHashEnd calls `rb_st_hash_end` in C
//
// Original definition is following
//
//	__attribute__((__const__)) st_index_t rb_st_hash_end(st_index_t h)
func RbStHashEnd(h StIndexT) StIndexT {
	return StIndexT(C.rb_st_hash_end(C.st_index_t(h)))
}

// RbStHashStart calls `rb_st_hash_start` in C
//
// Original definition is following
//
//	__attribute__((__const__)) st_index_t rb_st_hash_start(st_index_t h)
func RbStHashStart(h StIndexT) StIndexT {
	return StIndexT(C.rb_st_hash_start(C.st_index_t(h)))
}

// RbStHashUint calls `rb_st_hash_uint` in C
//
// Original definition is following
//
//	__attribute__((__const__)) st_index_t rb_st_hash_uint(st_index_t h, st_index_t i)
func RbStHashUint(h StIndexT, i StIndexT) StIndexT {
	return StIndexT(C.rb_st_hash_uint(C.st_index_t(h), C.st_index_t(i)))
}

// RbStHashUint32 calls `rb_st_hash_uint32` in C
//
// Original definition is following
//
//	__attribute__((__const__)) st_index_t rb_st_hash_uint32(st_index_t h, uint32_t i)
func RbStHashUint32(h StIndexT, i Uint32T) StIndexT {
	return StIndexT(C.rb_st_hash_uint32(C.st_index_t(h), C.uint32_t(i)))
}

// RbStInitExistingTableWithSize calls `rb_st_init_existing_table_with_size` in C
//
// Original definition is following
//
//	st_table *rb_st_init_existing_table_with_size(st_table *tab, const struct st_hash_type *type, st_index_t size)
func RbStInitExistingTableWithSize(tab *StTable, t *StHashType, size StIndexT) *StTable {
	var cTab C.st_table
	var cT C.struct_st_hash_type
	ret := (*StTable)(C.rb_st_init_existing_table_with_size(&cTab, &cT, C.st_index_t(size)))
	*tab = StTable(cTab)
	*t = StHashType(cT)
	return ret
}

// RbStInitNumtable calls `rb_st_init_numtable` in C
//
// Original definition is following
//
//	st_table *rb_st_init_numtable(void)
func RbStInitNumtable() *StTable {
	return (*StTable)(C.rb_st_init_numtable())
}

// RbStInitNumtableWithSize calls `rb_st_init_numtable_with_size` in C
//
// Original definition is following
//
//	st_table *rb_st_init_numtable_with_size(st_index_t)
func RbStInitNumtableWithSize(arg1 StIndexT) *StTable {
	return (*StTable)(C.rb_st_init_numtable_with_size(C.st_index_t(arg1)))
}

// RbStInitStrcasetable calls `rb_st_init_strcasetable` in C
//
// Original definition is following
//
//	st_table *rb_st_init_strcasetable(void)
func RbStInitStrcasetable() *StTable {
	return (*StTable)(C.rb_st_init_strcasetable())
}

// RbStInitStrcasetableWithSize calls `rb_st_init_strcasetable_with_size` in C
//
// Original definition is following
//
//	st_table *rb_st_init_strcasetable_with_size(st_index_t)
func RbStInitStrcasetableWithSize(arg1 StIndexT) *StTable {
	return (*StTable)(C.rb_st_init_strcasetable_with_size(C.st_index_t(arg1)))
}

// RbStInitStrtable calls `rb_st_init_strtable` in C
//
// Original definition is following
//
//	st_table *rb_st_init_strtable(void)
func RbStInitStrtable() *StTable {
	return (*StTable)(C.rb_st_init_strtable())
}

// RbStInitStrtableWithSize calls `rb_st_init_strtable_with_size` in C
//
// Original definition is following
//
//	st_table *rb_st_init_strtable_with_size(st_index_t)
func RbStInitStrtableWithSize(arg1 StIndexT) *StTable {
	return (*StTable)(C.rb_st_init_strtable_with_size(C.st_index_t(arg1)))
}

// RbStInitTable calls `rb_st_init_table` in C
//
// Original definition is following
//
//	st_table *rb_st_init_table(const struct st_hash_type *)
func RbStInitTable(arg1 *StHashType) *StTable {
	var cArg1 C.struct_st_hash_type
	ret := (*StTable)(C.rb_st_init_table(&cArg1))
	*arg1 = StHashType(cArg1)
	return ret
}

// RbStInitTableWithSize calls `rb_st_init_table_with_size` in C
//
// Original definition is following
//
//	st_table *rb_st_init_table_with_size(const struct st_hash_type *, st_index_t)
func RbStInitTableWithSize(arg1 *StHashType, arg2 StIndexT) *StTable {
	var cArg1 C.struct_st_hash_type
	ret := (*StTable)(C.rb_st_init_table_with_size(&cArg1, C.st_index_t(arg2)))
	*arg1 = StHashType(cArg1)
	return ret
}

// RbStInsert calls `rb_st_insert` in C
//
// Original definition is following
//
//	int rb_st_insert(st_table *, st_data_t, st_data_t)
func RbStInsert(arg1 *StTable, arg2 StDataT, arg3 StDataT) int {
	var cArg1 C.st_table
	ret := int(C.rb_st_insert(&cArg1, C.st_data_t(arg2), C.st_data_t(arg3)))
	*arg1 = StTable(cArg1)
	return ret
}

// RbStInsert2 calls `rb_st_insert2` in C
//
// Original definition is following
//
//	int rb_st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t))
func RbStInsert2(arg1 *StTable, arg2 StDataT, arg3 StDataT, arg4 unsafe.Pointer) int {
	var cArg1 C.st_table
	ret := int(C.rb_st_insert2(&cArg1, C.st_data_t(arg2), C.st_data_t(arg3), toCFunctionPointer(arg4)))
	*arg1 = StTable(cArg1)
	return ret
}

// RbStKeys calls `rb_st_keys` in C
//
// Original definition is following
//
//	st_index_t rb_st_keys(st_table *table, st_data_t *keys, st_index_t size)
func RbStKeys(table *StTable, keys *StDataT, size StIndexT) StIndexT {
	var cTable C.st_table
	var cKeys C.st_data_t
	ret := StIndexT(C.rb_st_keys(&cTable, &cKeys, C.st_index_t(size)))
	*table = StTable(cTable)
	*keys = StDataT(cKeys)
	return ret
}

// RbStKeysCheck calls `rb_st_keys_check` in C
//
// Original definition is following
//
//	st_index_t rb_st_keys_check(st_table *table, st_data_t *keys, st_index_t size, st_data_t never)
func RbStKeysCheck(table *StTable, keys *StDataT, size StIndexT, never StDataT) StIndexT {
	var cTable C.st_table
	var cKeys C.st_data_t
	ret := StIndexT(C.rb_st_keys_check(&cTable, &cKeys, C.st_index_t(size), C.st_data_t(never)))
	*table = StTable(cTable)
	*keys = StDataT(cKeys)
	return ret
}

// RbStLocaleInsensitiveStrcasecmp calls `rb_st_locale_insensitive_strcasecmp` in C
//
// Original definition is following
//
//	__attribute__((__pure__)) int rb_st_locale_insensitive_strcasecmp(const char *s1, const char *s2)
func RbStLocaleInsensitiveStrcasecmp(s1 string, s2 string) int {
	charS1, cleanChars1 := string2Char(s1)
	defer cleanChars1()

	charS2, cleanChars2 := string2Char(s2)
	defer cleanChars2()

	return int(C.rb_st_locale_insensitive_strcasecmp(charS1, charS2))
}

// RbStLocaleInsensitiveStrncasecmp calls `rb_st_locale_insensitive_strncasecmp` in C
//
// Original definition is following
//
//	__attribute__((__pure__)) int rb_st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n)
func RbStLocaleInsensitiveStrncasecmp(s1 string, s2 string, n SizeT) int {
	charS1, cleanChars1 := string2Char(s1)
	defer cleanChars1()

	charS2, cleanChars2 := string2Char(s2)
	defer cleanChars2()

	return int(C.rb_st_locale_insensitive_strncasecmp(charS1, charS2, C.size_t(n)))
}

// RbStLookup calls `rb_st_lookup` in C
//
// Original definition is following
//
//	int rb_st_lookup(st_table *, st_data_t, st_data_t *)
func RbStLookup(arg1 *StTable, arg2 StDataT, arg3 *StDataT) int {
	var cArg1 C.st_table
	var cArg3 C.st_data_t
	ret := int(C.rb_st_lookup(&cArg1, C.st_data_t(arg2), &cArg3))
	*arg1 = StTable(cArg1)
	*arg3 = StDataT(cArg3)
	return ret
}

// RbStMemsize calls `rb_st_memsize` in C
//
// Original definition is following
//
//	__attribute__((__pure__)) size_t rb_st_memsize(const st_table *)
func RbStMemsize(arg1 *StTable) SizeT {
	var cArg1 C.st_table
	ret := SizeT(C.rb_st_memsize(&cArg1))
	*arg1 = StTable(cArg1)
	return ret
}

// RbStNumcmp calls `rb_st_numcmp` in C
//
// Original definition is following
//
//	__attribute__((__const__)) int rb_st_numcmp(st_data_t, st_data_t)
func RbStNumcmp(arg1 StDataT, arg2 StDataT) int {
	return int(C.rb_st_numcmp(C.st_data_t(arg1), C.st_data_t(arg2)))
}

// RbStNumhash calls `rb_st_numhash` in C
//
// Original definition is following
//
//	__attribute__((__const__)) st_index_t rb_st_numhash(st_data_t)
func RbStNumhash(arg1 StDataT) StIndexT {
	return StIndexT(C.rb_st_numhash(C.st_data_t(arg1)))
}

// RbStReplace calls `rb_st_replace` in C
//
// Original definition is following
//
//	st_table *rb_st_replace(st_table *new_tab, st_table *old_tab)
func RbStReplace(new_tab *StTable, old_tab *StTable) *StTable {
	var cNewTab C.st_table
	var cOldTab C.st_table
	ret := (*StTable)(C.rb_st_replace(&cNewTab, &cOldTab))
	*new_tab = StTable(cNewTab)
	*old_tab = StTable(cOldTab)
	return ret
}

// RbStShift calls `rb_st_shift` in C
//
// Original definition is following
//
//	int rb_st_shift(st_table *, st_data_t *, st_data_t *)
func RbStShift(arg1 *StTable, arg2 *StDataT, arg3 *StDataT) int {
	var cArg1 C.st_table
	var cArg2 C.st_data_t
	var cArg3 C.st_data_t
	ret := int(C.rb_st_shift(&cArg1, &cArg2, &cArg3))
	*arg1 = StTable(cArg1)
	*arg2 = StDataT(cArg2)
	*arg3 = StDataT(cArg3)
	return ret
}

// RbStTableSize calls `rb_st_table_size` in C
//
// Original definition is following
//
//	size_t rb_st_table_size(const struct st_table *tbl)
func RbStTableSize(tbl *StTable) SizeT {
	var cTbl C.st_table
	ret := SizeT(C.rb_st_table_size(&cTbl))
	*tbl = StTable(cTbl)
	return ret
}

// RbStUpdate calls `rb_st_update` in C
//
// Original definition is following
//
//	int rb_st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg)
func RbStUpdate(table *StTable, key StDataT, fun *StUpdateCallbackFunc, arg StDataT) int {
	var cTable C.st_table
	var cFun C.st_update_callback_func
	ret := int(C.rb_st_update(&cTable, C.st_data_t(key), &cFun, C.st_data_t(arg)))
	*table = StTable(cTable)
	*fun = StUpdateCallbackFunc(cFun)
	return ret
}

// RbStValues calls `rb_st_values` in C
//
// Original definition is following
//
//	st_index_t rb_st_values(st_table *table, st_data_t *values, st_index_t size)
func RbStValues(table *StTable, values *StDataT, size StIndexT) StIndexT {
	var cTable C.st_table
	var cValues C.st_data_t
	ret := StIndexT(C.rb_st_values(&cTable, &cValues, C.st_index_t(size)))
	*table = StTable(cTable)
	*values = StDataT(cValues)
	return ret
}

// RbStValuesCheck calls `rb_st_values_check` in C
//
// Original definition is following
//
//	st_index_t rb_st_values_check(st_table *table, st_data_t *values, st_index_t size, st_data_t never)
func RbStValuesCheck(table *StTable, values *StDataT, size StIndexT, never StDataT) StIndexT {
	var cTable C.st_table
	var cValues C.st_data_t
	ret := StIndexT(C.rb_st_values_check(&cTable, &cValues, C.st_index_t(size), C.st_data_t(never)))
	*table = StTable(cTable)
	*values = StDataT(cValues)
	return ret
}

// RbStr2Inum calls `rb_str2inum` in C
//
// Original definition is following
//
//	VALUE rb_str2inum(VALUE str, int base)
func RbStr2Inum(str VALUE, base int) VALUE {
	return VALUE(C.rb_str2inum(C.VALUE(str), C.int(base)))
}

// RbStrAppend calls `rb_str_append` in C
//
// Original definition is following
//
//	VALUE rb_str_append(VALUE dst, VALUE src)
func RbStrAppend(dst VALUE, src VALUE) VALUE {
	return VALUE(C.rb_str_append(C.VALUE(dst), C.VALUE(src)))
}

// RbStrBufAppend calls `rb_str_buf_append` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_append(VALUE dst, VALUE src)
func RbStrBufAppend(dst VALUE, src VALUE) VALUE {
	return VALUE(C.rb_str_buf_append(C.VALUE(dst), C.VALUE(src)))
}

// RbStrBufCat calls `rb_str_buf_cat` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_cat(VALUE, const char*, long)
func RbStrBufCat(arg1 VALUE, arg2 string, arg3 Long) VALUE {
	char, clean := string2Char(arg2)
	defer clean()

	return VALUE(C.rb_str_buf_cat(C.VALUE(arg1), char, C.long(arg3)))
}

// RbStrBufCat2 calls `rb_str_buf_cat2` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_cat2(VALUE, const char*)
func RbStrBufCat2(arg1 VALUE, arg2 string) VALUE {
	char, clean := string2Char(arg2)
	defer clean()

	return VALUE(C.rb_str_buf_cat2(C.VALUE(arg1), char))
}

// RbStrBufCatAscii calls `rb_str_buf_cat_ascii` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src)
func RbStrBufCatAscii(dst VALUE, src string) VALUE {
	char, clean := string2Char(src)
	defer clean()

	return VALUE(C.rb_str_buf_cat_ascii(C.VALUE(dst), char))
}

// RbStrBufNew calls `rb_str_buf_new` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_new(long capa)
func RbStrBufNew(capa Long) VALUE {
	return VALUE(C.rb_str_buf_new(C.long(capa)))
}

// RbStrBufNewCstr calls `rb_str_buf_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_str_buf_new_cstr(const char *ptr)
func RbStrBufNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_str_buf_new_cstr(char))
}

// RbStrCapacity calls `rb_str_capacity` in C
//
// Original definition is following
//
//	size_t rb_str_capacity(VALUE str)
func RbStrCapacity(str VALUE) SizeT {
	return SizeT(C.rb_str_capacity(C.VALUE(str)))
}

// RbStrCat calls `rb_str_cat` in C
//
// Original definition is following
//
//	VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
func RbStrCat(dst VALUE, src string, srclen Long) VALUE {
	char, clean := string2Char(src)
	defer clean()

	return VALUE(C.rb_str_cat(C.VALUE(dst), char, C.long(srclen)))
}

// RbStrCat2 calls `rb_str_cat2` in C
//
// Original definition is following
//
//	VALUE rb_str_cat2(VALUE, const char*)
func RbStrCat2(arg1 VALUE, arg2 string) VALUE {
	char, clean := string2Char(arg2)
	defer clean()

	return VALUE(C.rb_str_cat2(C.VALUE(arg1), char))
}

// RbStrCatCstr calls `rb_str_cat_cstr` in C
//
// Original definition is following
//
//	VALUE rb_str_cat_cstr(VALUE dst, const char *src)
func RbStrCatCstr(dst VALUE, src string) VALUE {
	char, clean := string2Char(src)
	defer clean()

	return VALUE(C.rb_str_cat_cstr(C.VALUE(dst), char))
}

// RbStrCmp calls `rb_str_cmp` in C
//
// Original definition is following
//
//	int rb_str_cmp(VALUE lhs, VALUE rhs)
func RbStrCmp(lhs VALUE, rhs VALUE) int {
	return int(C.rb_str_cmp(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbStrComparable calls `rb_str_comparable` in C
//
// Original definition is following
//
//	int rb_str_comparable(VALUE str1, VALUE str2)
func RbStrComparable(str1 VALUE, str2 VALUE) int {
	return int(C.rb_str_comparable(C.VALUE(str1), C.VALUE(str2)))
}

// RbStrConcat calls `rb_str_concat` in C
//
// Original definition is following
//
//	VALUE rb_str_concat(VALUE dst, VALUE src)
func RbStrConcat(dst VALUE, src VALUE) VALUE {
	return VALUE(C.rb_str_concat(C.VALUE(dst), C.VALUE(src)))
}

// RbStrDropBytes calls `rb_str_drop_bytes` in C
//
// Original definition is following
//
//	VALUE rb_str_drop_bytes(VALUE str, long len)
func RbStrDropBytes(str VALUE, len Long) VALUE {
	return VALUE(C.rb_str_drop_bytes(C.VALUE(str), C.long(len)))
}

// RbStrDump calls `rb_str_dump` in C
//
// Original definition is following
//
//	VALUE rb_str_dump(VALUE str)
func RbStrDump(str VALUE) VALUE {
	return VALUE(C.rb_str_dump(C.VALUE(str)))
}

// RbStrDup calls `rb_str_dup` in C
//
// Original definition is following
//
//	VALUE rb_str_dup(VALUE str)
func RbStrDup(str VALUE) VALUE {
	return VALUE(C.rb_str_dup(C.VALUE(str)))
}

// RbStrDupFrozen calls `rb_str_dup_frozen` in C
//
// Original definition is following
//
//	VALUE rb_str_dup_frozen(VALUE)
func RbStrDupFrozen(arg1 VALUE) VALUE {
	return VALUE(C.rb_str_dup_frozen(C.VALUE(arg1)))
}

// RbStrEllipsize calls `rb_str_ellipsize` in C
//
// Original definition is following
//
//	VALUE rb_str_ellipsize(VALUE str, long len)
func RbStrEllipsize(str VALUE, len Long) VALUE {
	return VALUE(C.rb_str_ellipsize(C.VALUE(str), C.long(len)))
}

// RbStrEncodeOspath calls `rb_str_encode_ospath` in C
//
// Original definition is following
//
//	VALUE rb_str_encode_ospath(VALUE path)
func RbStrEncodeOspath(path VALUE) VALUE {
	return VALUE(C.rb_str_encode_ospath(C.VALUE(path)))
}

// RbStrEqual calls `rb_str_equal` in C
//
// Original definition is following
//
//	VALUE rb_str_equal(VALUE str1, VALUE str2)
func RbStrEqual(str1 VALUE, str2 VALUE) VALUE {
	return VALUE(C.rb_str_equal(C.VALUE(str1), C.VALUE(str2)))
}

// RbStrExport calls `rb_str_export` in C
//
// Original definition is following
//
//	VALUE rb_str_export(VALUE obj)
func RbStrExport(obj VALUE) VALUE {
	return VALUE(C.rb_str_export(C.VALUE(obj)))
}

// RbStrExportLocale calls `rb_str_export_locale` in C
//
// Original definition is following
//
//	VALUE rb_str_export_locale(VALUE obj)
func RbStrExportLocale(obj VALUE) VALUE {
	return VALUE(C.rb_str_export_locale(C.VALUE(obj)))
}

// RbStrFormat calls `rb_str_format` in C
//
// Original definition is following
//
//	VALUE rb_str_format(int argc, const VALUE *argv, VALUE fmt)
func RbStrFormat(argc int, argv *VALUE, fmt VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_str_format(C.int(argc), &cArgv, C.VALUE(fmt)))
	*argv = VALUE(cArgv)
	return ret
}

// RbStrFree calls `rb_str_free` in C
//
// Original definition is following
//
//	void rb_str_free(VALUE str)
func RbStrFree(str VALUE) {
	C.rb_str_free(C.VALUE(str))
}

// RbStrFreeze calls `rb_str_freeze` in C
//
// Original definition is following
//
//	VALUE rb_str_freeze(VALUE str)
func RbStrFreeze(str VALUE) VALUE {
	return VALUE(C.rb_str_freeze(C.VALUE(str)))
}

// RbStrHash calls `rb_str_hash` in C
//
// Original definition is following
//
//	st_index_t rb_str_hash(VALUE str)
func RbStrHash(str VALUE) StIndexT {
	return StIndexT(C.rb_str_hash(C.VALUE(str)))
}

// RbStrHashCmp calls `rb_str_hash_cmp` in C
//
// Original definition is following
//
//	int rb_str_hash_cmp(VALUE str1, VALUE str2)
func RbStrHashCmp(str1 VALUE, str2 VALUE) int {
	return int(C.rb_str_hash_cmp(C.VALUE(str1), C.VALUE(str2)))
}

// RbStrInspect calls `rb_str_inspect` in C
//
// Original definition is following
//
//	VALUE rb_str_inspect(VALUE str)
func RbStrInspect(str VALUE) VALUE {
	return VALUE(C.rb_str_inspect(C.VALUE(str)))
}

// RbStrIntern calls `rb_str_intern` in C
//
// Original definition is following
//
//	VALUE rb_str_intern(VALUE str)
func RbStrIntern(str VALUE) VALUE {
	return VALUE(C.rb_str_intern(C.VALUE(str)))
}

// RbStrLength calls `rb_str_length` in C
//
// Original definition is following
//
//	VALUE rb_str_length(VALUE)
func RbStrLength(arg1 VALUE) VALUE {
	return VALUE(C.rb_str_length(C.VALUE(arg1)))
}

// RbStrLocktmp calls `rb_str_locktmp` in C
//
// Original definition is following
//
//	VALUE rb_str_locktmp(VALUE str)
func RbStrLocktmp(str VALUE) VALUE {
	return VALUE(C.rb_str_locktmp(C.VALUE(str)))
}

// RbStrModify calls `rb_str_modify` in C
//
// Original definition is following
//
//	void rb_str_modify(VALUE str)
func RbStrModify(str VALUE) {
	C.rb_str_modify(C.VALUE(str))
}

// RbStrModifyExpand calls `rb_str_modify_expand` in C
//
// Original definition is following
//
//	void rb_str_modify_expand(VALUE str, long capa)
func RbStrModifyExpand(str VALUE, capa Long) {
	C.rb_str_modify_expand(C.VALUE(str), C.long(capa))
}

// RbStrNew calls `rb_str_new` in C
//
// Original definition is following
//
//	VALUE rb_str_new(const char *ptr, long len)
func RbStrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_str_new(char, C.long(len)))
}

// RbStrNewCstr calls `rb_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_str_new_cstr(const char *ptr)
func RbStrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_str_new_cstr(char))
}

// RbStrNewFrozen calls `rb_str_new_frozen` in C
//
// Original definition is following
//
//	VALUE rb_str_new_frozen(VALUE str)
func RbStrNewFrozen(str VALUE) VALUE {
	return VALUE(C.rb_str_new_frozen(C.VALUE(str)))
}

// RbStrNewShared calls `rb_str_new_shared` in C
//
// Original definition is following
//
//	VALUE rb_str_new_shared(VALUE str)
func RbStrNewShared(str VALUE) VALUE {
	return VALUE(C.rb_str_new_shared(C.VALUE(str)))
}

// RbStrNewStatic calls `rb_str_new_static` in C
//
// Original definition is following
//
//	VALUE rb_str_new_static(const char *ptr, long len)
func RbStrNewStatic(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_str_new_static(char, C.long(len)))
}

// RbStrNewWithClass calls `rb_str_new_with_class` in C
//
// Original definition is following
//
//	VALUE rb_str_new_with_class(VALUE obj, const char *ptr, long len)
func RbStrNewWithClass(obj VALUE, ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_str_new_with_class(C.VALUE(obj), char, C.long(len)))
}

// RbStrOffset calls `rb_str_offset` in C
//
// Original definition is following
//
//	long rb_str_offset(VALUE str, long pos)
func RbStrOffset(str VALUE, pos Long) Long {
	return Long(C.rb_str_offset(C.VALUE(str), C.long(pos)))
}

// RbStrPlus calls `rb_str_plus` in C
//
// Original definition is following
//
//	VALUE rb_str_plus(VALUE lhs, VALUE rhs)
func RbStrPlus(lhs VALUE, rhs VALUE) VALUE {
	return VALUE(C.rb_str_plus(C.VALUE(lhs), C.VALUE(rhs)))
}

// RbStrReplace calls `rb_str_replace` in C
//
// Original definition is following
//
//	VALUE rb_str_replace(VALUE dst, VALUE src)
func RbStrReplace(dst VALUE, src VALUE) VALUE {
	return VALUE(C.rb_str_replace(C.VALUE(dst), C.VALUE(src)))
}

// RbStrResize calls `rb_str_resize` in C
//
// Original definition is following
//
//	VALUE rb_str_resize(VALUE str, long len)
func RbStrResize(str VALUE, len Long) VALUE {
	return VALUE(C.rb_str_resize(C.VALUE(str), C.long(len)))
}

// RbStrResurrect calls `rb_str_resurrect` in C
//
// Original definition is following
//
//	VALUE rb_str_resurrect(VALUE str)
func RbStrResurrect(str VALUE) VALUE {
	return VALUE(C.rb_str_resurrect(C.VALUE(str)))
}

// RbStrScrub calls `rb_str_scrub` in C
//
// Original definition is following
//
//	VALUE rb_str_scrub(VALUE str, VALUE repl)
func RbStrScrub(str VALUE, repl VALUE) VALUE {
	return VALUE(C.rb_str_scrub(C.VALUE(str), C.VALUE(repl)))
}

// RbStrSetLen calls `rb_str_set_len` in C
//
// Original definition is following
//
//	void rb_str_set_len(VALUE str, long len)
func RbStrSetLen(str VALUE, len Long) {
	C.rb_str_set_len(C.VALUE(str), C.long(len))
}

// RbStrSharedReplace calls `rb_str_shared_replace` in C
//
// Original definition is following
//
//	void rb_str_shared_replace(VALUE dst, VALUE src)
func RbStrSharedReplace(dst VALUE, src VALUE) {
	C.rb_str_shared_replace(C.VALUE(dst), C.VALUE(src))
}

// RbStrSplit calls `rb_str_split` in C
//
// Original definition is following
//
//	VALUE rb_str_split(VALUE str, const char *delim)
func RbStrSplit(str VALUE, delim string) VALUE {
	char, clean := string2Char(delim)
	defer clean()

	return VALUE(C.rb_str_split(C.VALUE(str), char))
}

// RbStrStrlen calls `rb_str_strlen` in C
//
// Original definition is following
//
//	long rb_str_strlen(VALUE str)
func RbStrStrlen(str VALUE) Long {
	return Long(C.rb_str_strlen(C.VALUE(str)))
}

// RbStrSublen calls `rb_str_sublen` in C
//
// Original definition is following
//
//	long rb_str_sublen(VALUE str, long pos)
func RbStrSublen(str VALUE, pos Long) Long {
	return Long(C.rb_str_sublen(C.VALUE(str), C.long(pos)))
}

// RbStrSubpos calls `rb_str_subpos` in C
//
// Original definition is following
//
//	char *rb_str_subpos(VALUE str, long beg, long *len)
func RbStrSubpos(str VALUE, beg Long, len *Long) string {
	var cLen C.long
	ret := char2String(C.rb_str_subpos(C.VALUE(str), C.long(beg), &cLen))
	*len = Long(cLen)
	return ret
}

// RbStrSubseq calls `rb_str_subseq` in C
//
// Original definition is following
//
//	VALUE rb_str_subseq(VALUE str, long beg, long len)
func RbStrSubseq(str VALUE, beg Long, len Long) VALUE {
	return VALUE(C.rb_str_subseq(C.VALUE(str), C.long(beg), C.long(len)))
}

// RbStrSubstr calls `rb_str_substr` in C
//
// Original definition is following
//
//	VALUE rb_str_substr(VALUE str, long beg, long len)
func RbStrSubstr(str VALUE, beg Long, len Long) VALUE {
	return VALUE(C.rb_str_substr(C.VALUE(str), C.long(beg), C.long(len)))
}

// RbStrSucc calls `rb_str_succ` in C
//
// Original definition is following
//
//	VALUE rb_str_succ(VALUE orig)
func RbStrSucc(orig VALUE) VALUE {
	return VALUE(C.rb_str_succ(C.VALUE(orig)))
}

// RbStrTimes calls `rb_str_times` in C
//
// Original definition is following
//
//	VALUE rb_str_times(VALUE str, VALUE num)
func RbStrTimes(str VALUE, num VALUE) VALUE {
	return VALUE(C.rb_str_times(C.VALUE(str), C.VALUE(num)))
}

// RbStrTmpNew calls `rb_str_tmp_new` in C
//
// Original definition is following
//
//	VALUE rb_str_tmp_new(long len)
func RbStrTmpNew(len Long) VALUE {
	return VALUE(C.rb_str_tmp_new(C.long(len)))
}

// RbStrToDbl calls `rb_str_to_dbl` in C
//
// Original definition is following
//
//	double rb_str_to_dbl(VALUE str, int mode)
func RbStrToDbl(str VALUE, mode int) Double {
	return Double(C.rb_str_to_dbl(C.VALUE(str), C.int(mode)))
}

// RbStrToInternedStr calls `rb_str_to_interned_str` in C
//
// Original definition is following
//
//	VALUE rb_str_to_interned_str(VALUE str)
func RbStrToInternedStr(str VALUE) VALUE {
	return VALUE(C.rb_str_to_interned_str(C.VALUE(str)))
}

// RbStrToInum calls `rb_str_to_inum` in C
//
// Original definition is following
//
//	VALUE rb_str_to_inum(VALUE str, int base, int badcheck)
func RbStrToInum(str VALUE, base int, badcheck int) VALUE {
	return VALUE(C.rb_str_to_inum(C.VALUE(str), C.int(base), C.int(badcheck)))
}

// RbStrToStr calls `rb_str_to_str` in C
//
// Original definition is following
//
//	VALUE rb_str_to_str(VALUE obj)
func RbStrToStr(obj VALUE) VALUE {
	return VALUE(C.rb_str_to_str(C.VALUE(obj)))
}

// RbStrUnlocktmp calls `rb_str_unlocktmp` in C
//
// Original definition is following
//
//	VALUE rb_str_unlocktmp(VALUE str)
func RbStrUnlocktmp(str VALUE) VALUE {
	return VALUE(C.rb_str_unlocktmp(C.VALUE(str)))
}

// RbStrUpdate calls `rb_str_update` in C
//
// Original definition is following
//
//	void rb_str_update(VALUE dst, long beg, long len, VALUE src)
func RbStrUpdate(dst VALUE, beg Long, len Long, src VALUE) {
	C.rb_str_update(C.VALUE(dst), C.long(beg), C.long(len), C.VALUE(src))
}

// RbStringValue calls `rb_string_value` in C
//
// Original definition is following
//
//	VALUE rb_string_value(volatile VALUE *ptr)
func RbStringValue(ptr *VALUE) VALUE {
	var cPtr C.VALUE
	ret := VALUE(C.rb_string_value(&cPtr))
	*ptr = VALUE(cPtr)
	return ret
}

// RbStringValueCstr calls `rb_string_value_cstr` in C
//
// Original definition is following
//
//	char *rb_string_value_cstr(volatile VALUE *ptr)
func RbStringValueCstr(ptr *VALUE) string {
	var cPtr C.VALUE
	ret := char2String(C.rb_string_value_cstr(&cPtr))
	*ptr = VALUE(cPtr)
	return ret
}

// RbStringValuePtr calls `rb_string_value_ptr` in C
//
// Original definition is following
//
//	char *rb_string_value_ptr(volatile VALUE *ptr)
func RbStringValuePtr(ptr *VALUE) string {
	var cPtr C.VALUE
	ret := char2String(C.rb_string_value_ptr(&cPtr))
	*ptr = VALUE(cPtr)
	return ret
}

// RbStructAlloc calls `rb_struct_alloc` in C
//
// Original definition is following
//
//	VALUE rb_struct_alloc(VALUE klass, VALUE values)
func RbStructAlloc(klass VALUE, values VALUE) VALUE {
	return VALUE(C.rb_struct_alloc(C.VALUE(klass), C.VALUE(values)))
}

// RbStructAllocNoinit calls `rb_struct_alloc_noinit` in C
//
// Original definition is following
//
//	VALUE rb_struct_alloc_noinit(VALUE klass)
func RbStructAllocNoinit(klass VALUE) VALUE {
	return VALUE(C.rb_struct_alloc_noinit(C.VALUE(klass)))
}

// RbStructAref calls `rb_struct_aref` in C
//
// Original definition is following
//
//	VALUE rb_struct_aref(VALUE st, VALUE k)
func RbStructAref(st VALUE, k VALUE) VALUE {
	return VALUE(C.rb_struct_aref(C.VALUE(st), C.VALUE(k)))
}

// RbStructAset calls `rb_struct_aset` in C
//
// Original definition is following
//
//	VALUE rb_struct_aset(VALUE st, VALUE k, VALUE v)
func RbStructAset(st VALUE, k VALUE, v VALUE) VALUE {
	return VALUE(C.rb_struct_aset(C.VALUE(st), C.VALUE(k), C.VALUE(v)))
}

// RbStructGetmember calls `rb_struct_getmember` in C
//
// Original definition is following
//
//	VALUE rb_struct_getmember(VALUE self, ID key)
func RbStructGetmember(self VALUE, key ID) VALUE {
	return VALUE(C.rb_struct_getmember(C.VALUE(self), C.ID(key)))
}

// RbStructInitialize calls `rb_struct_initialize` in C
//
// Original definition is following
//
//	VALUE rb_struct_initialize(VALUE self, VALUE values)
func RbStructInitialize(self VALUE, values VALUE) VALUE {
	return VALUE(C.rb_struct_initialize(C.VALUE(self), C.VALUE(values)))
}

// RbStructMembers calls `rb_struct_members` in C
//
// Original definition is following
//
//	VALUE rb_struct_members(VALUE self)
func RbStructMembers(self VALUE) VALUE {
	return VALUE(C.rb_struct_members(C.VALUE(self)))
}

// RbStructSMembers calls `rb_struct_s_members` in C
//
// Original definition is following
//
//	VALUE rb_struct_s_members(VALUE klass)
func RbStructSMembers(klass VALUE) VALUE {
	return VALUE(C.rb_struct_s_members(C.VALUE(klass)))
}

// RbStructSize calls `rb_struct_size` in C
//
// Original definition is following
//
//	VALUE rb_struct_size(VALUE st)
func RbStructSize(st VALUE) VALUE {
	return VALUE(C.rb_struct_size(C.VALUE(st)))
}

// RbSym2Id calls `rb_sym2id` in C
//
// Original definition is following
//
//	ID rb_sym2id(VALUE obj)
func RbSym2Id(obj VALUE) ID {
	return ID(C.rb_sym2id(C.VALUE(obj)))
}

// RbSym2Str calls `rb_sym2str` in C
//
// Original definition is following
//
//	VALUE rb_sym2str(VALUE id)
func RbSym2Str(id VALUE) VALUE {
	return VALUE(C.rb_sym2str(C.VALUE(id)))
}

// RbSymAllSymbols calls `rb_sym_all_symbols` in C
//
// Original definition is following
//
//	VALUE rb_sym_all_symbols(void)
func RbSymAllSymbols() VALUE {
	return VALUE(C.rb_sym_all_symbols())
}

// RbSymToS calls `rb_sym_to_s` in C
//
// Original definition is following
//
//	VALUE rb_sym_to_s(VALUE sym)
func RbSymToS(sym VALUE) VALUE {
	return VALUE(C.rb_sym_to_s(C.VALUE(sym)))
}

// RbSymnameP calls `rb_symname_p` in C
//
// Original definition is following
//
//	int rb_symname_p(const char *str)
func RbSymnameP(str string) int {
	char, clean := string2Char(str)
	defer clean()

	return int(C.rb_symname_p(char))
}

// RbSysFail calls `rb_sys_fail` in C
//
// Original definition is following
//
//	void rb_sys_fail(const char *msg)
func RbSysFail(msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_sys_fail(char)
}

// RbSysFailStr calls `rb_sys_fail_str` in C
//
// Original definition is following
//
//	void rb_sys_fail_str(VALUE msg)
func RbSysFailStr(msg VALUE) {
	C.rb_sys_fail_str(C.VALUE(msg))
}

// RbSyserrFail calls `rb_syserr_fail` in C
//
// Original definition is following
//
//	void rb_syserr_fail(int err, const char *msg)
func RbSyserrFail(err int, msg string) {
	char, clean := string2Char(msg)
	defer clean()

	C.rb_syserr_fail(C.int(err), char)
}

// RbSyserrFailStr calls `rb_syserr_fail_str` in C
//
// Original definition is following
//
//	void rb_syserr_fail_str(int err, VALUE msg)
func RbSyserrFailStr(err int, msg VALUE) {
	C.rb_syserr_fail_str(C.int(err), C.VALUE(msg))
}

// RbSyserrNew calls `rb_syserr_new` in C
//
// Original definition is following
//
//	VALUE rb_syserr_new(int err, const char * msg)
func RbSyserrNew(err int, msg string) VALUE {
	char, clean := string2Char(msg)
	defer clean()

	return VALUE(C.rb_syserr_new(C.int(err), char))
}

// RbSyserrNewStr calls `rb_syserr_new_str` in C
//
// Original definition is following
//
//	VALUE rb_syserr_new_str(int n, VALUE arg)
func RbSyserrNewStr(n int, arg VALUE) VALUE {
	return VALUE(C.rb_syserr_new_str(C.int(n), C.VALUE(arg)))
}

// RbSyswait calls `rb_syswait` in C
//
// Original definition is following
//
//	void rb_syswait(pid_t pid)
func RbSyswait(pid PidT) {
	C.rb_syswait(C.pid_t(pid))
}

// RbThreadAlone calls `rb_thread_alone` in C
//
// Original definition is following
//
//	int rb_thread_alone(void)
func RbThreadAlone() int {
	return int(C.rb_thread_alone())
}

// RbThreadAtfork calls `rb_thread_atfork` in C
//
// Original definition is following
//
//	void rb_thread_atfork(void)
func RbThreadAtfork() {
	C.rb_thread_atfork()
}

// RbThreadAtforkBeforeExec calls `rb_thread_atfork_before_exec` in C
//
// Original definition is following
//
//	void rb_thread_atfork_before_exec(void)
func RbThreadAtforkBeforeExec() {
	C.rb_thread_atfork_before_exec()
}

// RbThreadCheckInts calls `rb_thread_check_ints` in C
//
// Original definition is following
//
//	void rb_thread_check_ints(void)
func RbThreadCheckInts() {
	C.rb_thread_check_ints()
}

// RbThreadCreate calls `rb_thread_create` in C
//
// Original definition is following
//
//	VALUE rb_thread_create(VALUE (*f)(void *g), void *g)
func RbThreadCreate(arg1 unsafe.Pointer, g unsafe.Pointer) VALUE {
	return VALUE(C.rb_thread_create(toCFunctionPointer(arg1), g))
}

// RbThreadCurrent calls `rb_thread_current` in C
//
// Original definition is following
//
//	VALUE rb_thread_current(void)
func RbThreadCurrent() VALUE {
	return VALUE(C.rb_thread_current())
}

// RbThreadFdClose calls `rb_thread_fd_close` in C
//
// Original definition is following
//
//	void rb_thread_fd_close(int fd)
func RbThreadFdClose(fd int) {
	C.rb_thread_fd_close(C.int(fd))
}

// RbThreadFdSelect calls `rb_thread_fd_select` in C
//
// Original definition is following
//
//	int rb_thread_fd_select(int nfds, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)
func RbThreadFdSelect(nfds int, rfds *RbFdsetT, wfds *RbFdsetT, efds *RbFdsetT, timeout *Timeval) int {
	var cRfds C.rb_fdset_t
	var cWfds C.rb_fdset_t
	var cEfds C.rb_fdset_t
	var cTimeout C.struct_timeval
	ret := int(C.rb_thread_fd_select(C.int(nfds), &cRfds, &cWfds, &cEfds, &cTimeout))
	*rfds = RbFdsetT(cRfds)
	*wfds = RbFdsetT(cWfds)
	*efds = RbFdsetT(cEfds)
	*timeout = Timeval(cTimeout)
	return ret
}

// RbThreadFdWritable calls `rb_thread_fd_writable` in C
//
// Original definition is following
//
//	int rb_thread_fd_writable(int fd)
func RbThreadFdWritable(fd int) int {
	return int(C.rb_thread_fd_writable(C.int(fd)))
}

// RbThreadInterrupted calls `rb_thread_interrupted` in C
//
// Original definition is following
//
//	int rb_thread_interrupted(VALUE thval)
func RbThreadInterrupted(thval VALUE) int {
	return int(C.rb_thread_interrupted(C.VALUE(thval)))
}

// RbThreadKill calls `rb_thread_kill` in C
//
// Original definition is following
//
//	VALUE rb_thread_kill(VALUE thread)
func RbThreadKill(thread VALUE) VALUE {
	return VALUE(C.rb_thread_kill(C.VALUE(thread)))
}

// RbThreadLocalAref calls `rb_thread_local_aref` in C
//
// Original definition is following
//
//	VALUE rb_thread_local_aref(VALUE thread, ID key)
func RbThreadLocalAref(thread VALUE, key ID) VALUE {
	return VALUE(C.rb_thread_local_aref(C.VALUE(thread), C.ID(key)))
}

// RbThreadLocalAset calls `rb_thread_local_aset` in C
//
// Original definition is following
//
//	VALUE rb_thread_local_aset(VALUE thread, ID key, VALUE val)
func RbThreadLocalAset(thread VALUE, key ID, val VALUE) VALUE {
	return VALUE(C.rb_thread_local_aset(C.VALUE(thread), C.ID(key), C.VALUE(val)))
}

// RbThreadMain calls `rb_thread_main` in C
//
// Original definition is following
//
//	VALUE rb_thread_main(void)
func RbThreadMain() VALUE {
	return VALUE(C.rb_thread_main())
}

// RbThreadRun calls `rb_thread_run` in C
//
// Original definition is following
//
//	VALUE rb_thread_run(VALUE thread)
func RbThreadRun(thread VALUE) VALUE {
	return VALUE(C.rb_thread_run(C.VALUE(thread)))
}

// RbThreadSchedule calls `rb_thread_schedule` in C
//
// Original definition is following
//
//	void rb_thread_schedule(void)
func RbThreadSchedule() {
	C.rb_thread_schedule()
}

// RbThreadSleep calls `rb_thread_sleep` in C
//
// Original definition is following
//
//	void rb_thread_sleep(int sec)
func RbThreadSleep(sec int) {
	C.rb_thread_sleep(C.int(sec))
}

// RbThreadSleepDeadly calls `rb_thread_sleep_deadly` in C
//
// Original definition is following
//
//	void rb_thread_sleep_deadly(void)
func RbThreadSleepDeadly() {
	C.rb_thread_sleep_deadly()
}

// RbThreadSleepForever calls `rb_thread_sleep_forever` in C
//
// Original definition is following
//
//	void rb_thread_sleep_forever(void)
func RbThreadSleepForever() {
	C.rb_thread_sleep_forever()
}

// RbThreadStop calls `rb_thread_stop` in C
//
// Original definition is following
//
//	VALUE rb_thread_stop(void)
func RbThreadStop() VALUE {
	return VALUE(C.rb_thread_stop())
}

// RbThreadWaitFd calls `rb_thread_wait_fd` in C
//
// Original definition is following
//
//	int rb_thread_wait_fd(int fd)
func RbThreadWaitFd(fd int) int {
	return int(C.rb_thread_wait_fd(C.int(fd)))
}

// RbThreadWaitFor calls `rb_thread_wait_for` in C
//
// Original definition is following
//
//	void rb_thread_wait_for(struct timeval time)
func RbThreadWaitFor(time Timeval) {
	C.rb_thread_wait_for(C.struct_timeval(time))
}

// RbThreadWakeup calls `rb_thread_wakeup` in C
//
// Original definition is following
//
//	VALUE rb_thread_wakeup(VALUE thread)
func RbThreadWakeup(thread VALUE) VALUE {
	return VALUE(C.rb_thread_wakeup(C.VALUE(thread)))
}

// RbThreadWakeupAlive calls `rb_thread_wakeup_alive` in C
//
// Original definition is following
//
//	VALUE rb_thread_wakeup_alive(VALUE thread)
func RbThreadWakeupAlive(thread VALUE) VALUE {
	return VALUE(C.rb_thread_wakeup_alive(C.VALUE(thread)))
}

// RbThrow calls `rb_throw` in C
//
// Original definition is following
//
//	void rb_throw(const char *tag, VALUE val)
func RbThrow(tag string, val VALUE) {
	char, clean := string2Char(tag)
	defer clean()

	C.rb_throw(char, C.VALUE(val))
}

// RbThrowObj calls `rb_throw_obj` in C
//
// Original definition is following
//
//	void rb_throw_obj(VALUE tag, VALUE val)
func RbThrowObj(tag VALUE, val VALUE) {
	C.rb_throw_obj(C.VALUE(tag), C.VALUE(val))
}

// RbTimeInterval calls `rb_time_interval` in C
//
// Original definition is following
//
//	struct timeval rb_time_interval(VALUE num)
func RbTimeInterval(num VALUE) Timeval {
	return Timeval(C.rb_time_interval(C.VALUE(num)))
}

// RbTimeNanoNew calls `rb_time_nano_new` in C
//
// Original definition is following
//
//	VALUE rb_time_nano_new(time_t sec, long nsec)
func RbTimeNanoNew(sec TimeT, nsec Long) VALUE {
	return VALUE(C.rb_time_nano_new(C.time_t(sec), C.long(nsec)))
}

// RbTimeNew calls `rb_time_new` in C
//
// Original definition is following
//
//	VALUE rb_time_new(time_t sec, long usec)
func RbTimeNew(sec TimeT, usec Long) VALUE {
	return VALUE(C.rb_time_new(C.time_t(sec), C.long(usec)))
}

// RbTimeNumNew calls `rb_time_num_new` in C
//
// Original definition is following
//
//	VALUE rb_time_num_new(VALUE timev, VALUE off)
func RbTimeNumNew(timev VALUE, off VALUE) VALUE {
	return VALUE(C.rb_time_num_new(C.VALUE(timev), C.VALUE(off)))
}

// RbTimeTimespec calls `rb_time_timespec` in C
//
// Original definition is following
//
//	struct timespec rb_time_timespec(VALUE time)
func RbTimeTimespec(time VALUE) Timespec {
	return Timespec(C.rb_time_timespec(C.VALUE(time)))
}

// RbTimeTimespecInterval calls `rb_time_timespec_interval` in C
//
// Original definition is following
//
//	struct timespec rb_time_timespec_interval(VALUE num)
func RbTimeTimespecInterval(num VALUE) Timespec {
	return Timespec(C.rb_time_timespec_interval(C.VALUE(num)))
}

// RbTimeTimespecNew calls `rb_time_timespec_new` in C
//
// Original definition is following
//
//	VALUE rb_time_timespec_new(const struct timespec *ts, int offset)
func RbTimeTimespecNew(ts *Timespec, offset int) VALUE {
	var cTs C.struct_timespec
	ret := VALUE(C.rb_time_timespec_new(&cTs, C.int(offset)))
	*ts = Timespec(cTs)
	return ret
}

// RbTimeTimeval calls `rb_time_timeval` in C
//
// Original definition is following
//
//	struct timeval rb_time_timeval(VALUE time)
func RbTimeTimeval(time VALUE) Timeval {
	return Timeval(C.rb_time_timeval(C.VALUE(time)))
}

// RbTimeUtcOffset calls `rb_time_utc_offset` in C
//
// Original definition is following
//
//	VALUE rb_time_utc_offset(VALUE time)
func RbTimeUtcOffset(time VALUE) VALUE {
	return VALUE(C.rb_time_utc_offset(C.VALUE(time)))
}

// RbTimespecNow calls `rb_timespec_now` in C
//
// Original definition is following
//
//	void rb_timespec_now(struct timespec *ts)
func RbTimespecNow(ts *Timespec) {
	var cTs C.struct_timespec
	C.rb_timespec_now(&cTs)
	*ts = Timespec(cTs)
}

// RbToFloat calls `rb_to_float` in C
//
// Original definition is following
//
//	VALUE rb_to_float(VALUE val)
func RbToFloat(val VALUE) VALUE {
	return VALUE(C.rb_to_float(C.VALUE(val)))
}

// RbToId calls `rb_to_id` in C
//
// Original definition is following
//
//	ID rb_to_id(VALUE str)
func RbToId(str VALUE) ID {
	return ID(C.rb_to_id(C.VALUE(str)))
}

// RbToInt calls `rb_to_int` in C
//
// Original definition is following
//
//	VALUE rb_to_int(VALUE val)
func RbToInt(val VALUE) VALUE {
	return VALUE(C.rb_to_int(C.VALUE(val)))
}

// RbToSymbol calls `rb_to_symbol` in C
//
// Original definition is following
//
//	VALUE rb_to_symbol(VALUE name)
func RbToSymbol(name VALUE) VALUE {
	return VALUE(C.rb_to_symbol(C.VALUE(name)))
}

// RbTolower calls `rb_tolower` in C
//
// Original definition is following
//
//	rb_tolower(int c)
func RbTolower(c int) int {
	return int(C.rb_tolower(C.int(c)))
}

// RbToupper calls `rb_toupper` in C
//
// Original definition is following
//
//	rb_toupper(int c)
func RbToupper(c int) int {
	return int(C.rb_toupper(C.int(c)))
}

// RbType calls `rb_type` in C
//
// Original definition is following
//
//	rb_type(VALUE obj)
func RbType(obj VALUE) RubyValueType {
	return RubyValueType(C.rb_type(C.VALUE(obj)))
}

// RbTypeddataInheritedP calls `rb_typeddata_inherited_p` in C
//
// Original definition is following
//
//	int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent)
func RbTypeddataInheritedP(child *RbDataTypeT, parent *RbDataTypeT) int {
	var cChild C.rb_data_type_t
	var cParent C.rb_data_type_t
	ret := int(C.rb_typeddata_inherited_p(&cChild, &cParent))
	*child = RbDataTypeT(cChild)
	*parent = RbDataTypeT(cParent)
	return ret
}

// RbTypeddataIsKindOf calls `rb_typeddata_is_kind_of` in C
//
// Original definition is following
//
//	int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
func RbTypeddataIsKindOf(obj VALUE, data_type *RbDataTypeT) int {
	var cDataType C.rb_data_type_t
	ret := int(C.rb_typeddata_is_kind_of(C.VALUE(obj), &cDataType))
	*data_type = RbDataTypeT(cDataType)
	return ret
}

// RbUint2Big calls `rb_uint2big` in C
//
// Original definition is following
//
//	VALUE rb_uint2big(uintptr_t i)
func RbUint2Big(i UintptrT) VALUE {
	return VALUE(C.rb_uint2big(C.uintptr_t(i)))
}

// RbUint2Inum calls `rb_uint2inum` in C
//
// Original definition is following
//
//	VALUE rb_uint2inum(uintptr_t i)
func RbUint2Inum(i UintptrT) VALUE {
	return VALUE(C.rb_uint2inum(C.uintptr_t(i)))
}

// RbUint2NumInline calls `rb_uint2num_inline` in C
//
// Original definition is following
//
//	rb_uint2num_inline(unsigned int v)
func RbUint2NumInline(v uint) VALUE {
	return VALUE(C.rb_uint2num_inline(C.uint(v)))
}

// RbUll2Inum calls `rb_ull2inum` in C
//
// Original definition is following
//
//	VALUE rb_ull2inum(unsigned
func RbUll2Inum(num Ulonglong) VALUE {
	return VALUE(C.rb_ull2inum(C.ulonglong(num)))
}

// RbUll2NumInline calls `rb_ull2num_inline` in C
//
// Original definition is following
//
//	rb_ull2num_inline(unsigned
func RbUll2NumInline(n Ulonglong) VALUE {
	return VALUE(C.rb_ull2num_inline(C.ulonglong(n)))
}

// RbUlong2NumInline calls `rb_ulong2num_inline` in C
//
// Original definition is following
//
//	rb_ulong2num_inline(unsigned long v)
func RbUlong2NumInline(v uint) VALUE {
	return VALUE(C.rb_ulong2num_inline(C.ulong(v)))
}

// RbUndef calls `rb_undef` in C
//
// Original definition is following
//
//	void rb_undef(VALUE mod, ID mid)
func RbUndef(mod VALUE, mid ID) {
	C.rb_undef(C.VALUE(mod), C.ID(mid))
}

// RbUndefAllocFunc calls `rb_undef_alloc_func` in C
//
// Original definition is following
//
//	void rb_undef_alloc_func(VALUE klass)
func RbUndefAllocFunc(klass VALUE) {
	C.rb_undef_alloc_func(C.VALUE(klass))
}

// RbUndefMethod calls `rb_undef_method` in C
//
// Original definition is following
//
//	void rb_undef_method(VALUE klass, const char *name)
func RbUndefMethod(klass VALUE, name string) {
	char, clean := string2Char(name)
	defer clean()

	C.rb_undef_method(C.VALUE(klass), char)
}

// RbUndefineFinalizer calls `rb_undefine_finalizer` in C
//
// Original definition is following
//
//	VALUE rb_undefine_finalizer(VALUE obj)
func RbUndefineFinalizer(obj VALUE) VALUE {
	return VALUE(C.rb_undefine_finalizer(C.VALUE(obj)))
}

// RbUnexpectedType calls `rb_unexpected_type` in C
//
// Original definition is following
//
//	void rb_unexpected_type(VALUE self, int t)
func RbUnexpectedType(self VALUE, t int) {
	C.rb_unexpected_type(C.VALUE(self), C.int(t))
}

// RbUpdateMaxFd calls `rb_update_max_fd` in C
//
// Original definition is following
//
//	void rb_update_max_fd(int fd)
func RbUpdateMaxFd(fd int) {
	C.rb_update_max_fd(C.int(fd))
}

// RbUsasciiStrNew calls `rb_usascii_str_new` in C
//
// Original definition is following
//
//	VALUE rb_usascii_str_new(const char *ptr, long len)
func RbUsasciiStrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_usascii_str_new(char, C.long(len)))
}

// RbUsasciiStrNewCstr calls `rb_usascii_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_usascii_str_new_cstr(const char *ptr)
func RbUsasciiStrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_usascii_str_new_cstr(char))
}

// RbUsasciiStrNewStatic calls `rb_usascii_str_new_static` in C
//
// Original definition is following
//
//	VALUE rb_usascii_str_new_static(const char *ptr, long len)
func RbUsasciiStrNewStatic(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_usascii_str_new_static(char, C.long(len)))
}

// RbUtf8StrNew calls `rb_utf8_str_new` in C
//
// Original definition is following
//
//	VALUE rb_utf8_str_new(const char *ptr, long len)
func RbUtf8StrNew(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_utf8_str_new(char, C.long(len)))
}

// RbUtf8StrNewCstr calls `rb_utf8_str_new_cstr` in C
//
// Original definition is following
//
//	VALUE rb_utf8_str_new_cstr(const char *ptr)
func RbUtf8StrNewCstr(ptr string) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_utf8_str_new_cstr(char))
}

// RbUtf8StrNewStatic calls `rb_utf8_str_new_static` in C
//
// Original definition is following
//
//	VALUE rb_utf8_str_new_static(const char *ptr, long len)
func RbUtf8StrNewStatic(ptr string, len Long) VALUE {
	char, clean := string2Char(ptr)
	defer clean()

	return VALUE(C.rb_utf8_str_new_static(char, C.long(len)))
}

// RbUvToUtf8 calls `rb_uv_to_utf8` in C
//
// Original definition is following
//
//	int rb_uv_to_utf8(char buf[6], unsigned long uv)
func RbUvToUtf8(buf []Char, uv uint) int {
	return int(C.rb_uv_to_utf8(toCArray[Char, C.char](buf), C.ulong(uv)))
}

// RbWaitpid calls `rb_waitpid` in C
//
// Original definition is following
//
//	pid_t rb_waitpid(pid_t pid, int *status, int flags)
func RbWaitpid(pid PidT, status *int, flags int) PidT {
	var cStatus C.int
	ret := PidT(C.rb_waitpid(C.pid_t(pid), &cStatus, C.int(flags)))
	*status = int(cStatus)
	return ret
}

// RbWriteError calls `rb_write_error` in C
//
// Original definition is following
//
//	void rb_write_error(const char *str)
func RbWriteError(str string) {
	char, clean := string2Char(str)
	defer clean()

	C.rb_write_error(char)
}

// RbWriteError2 calls `rb_write_error2` in C
//
// Original definition is following
//
//	void rb_write_error2(const char *str, long len)
func RbWriteError2(str string, len Long) {
	char, clean := string2Char(str)
	defer clean()

	C.rb_write_error2(char, C.long(len))
}

// RbYield calls `rb_yield` in C
//
// Original definition is following
//
//	VALUE rb_yield(VALUE val)
func RbYield(val VALUE) VALUE {
	return VALUE(C.rb_yield(C.VALUE(val)))
}

// RbYieldBlock calls `rb_yield_block` in C
//
// Original definition is following
//
//	VALUE rb_yield_block(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg)
func RbYieldBlock(yielded_arg VALUE, callback_arg VALUE, argc int, argv *VALUE, blockarg VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_yield_block(C.VALUE(yielded_arg), C.VALUE(callback_arg), C.int(argc), &cArgv, C.VALUE(blockarg)))
	*argv = VALUE(cArgv)
	return ret
}

// RbYieldSplat calls `rb_yield_splat` in C
//
// Original definition is following
//
//	VALUE rb_yield_splat(VALUE ary)
func RbYieldSplat(ary VALUE) VALUE {
	return VALUE(C.rb_yield_splat(C.VALUE(ary)))
}

// RbYieldSplatKw calls `rb_yield_splat_kw` in C
//
// Original definition is following
//
//	VALUE rb_yield_splat_kw(VALUE ary, int kw_splat)
func RbYieldSplatKw(ary VALUE, kw_splat int) VALUE {
	return VALUE(C.rb_yield_splat_kw(C.VALUE(ary), C.int(kw_splat)))
}

// RbYieldValues2 calls `rb_yield_values2` in C
//
// Original definition is following
//
//	VALUE rb_yield_values2(int n, const VALUE *argv)
func RbYieldValues2(n int, argv *VALUE) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_yield_values2(C.int(n), &cArgv))
	*argv = VALUE(cArgv)
	return ret
}

// RbYieldValuesKw calls `rb_yield_values_kw` in C
//
// Original definition is following
//
//	VALUE rb_yield_values_kw(int n, const VALUE *argv, int kw_splat)
func RbYieldValuesKw(n int, argv *VALUE, kw_splat int) VALUE {
	var cArgv C.VALUE
	ret := VALUE(C.rb_yield_values_kw(C.int(n), &cArgv, C.int(kw_splat)))
	*argv = VALUE(cArgv)
	return ret
}