// Generating code for gctools::gctools__register_loaded_objects
 LCC_RETURN wrapped_gctools__register_loaded_objects_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__register_loaded_objects();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__ensure_valid
 LCC_RETURN wrapped_gctools__ensure_valid_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::gctools__ensure_valid(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__multiple_values_ensure_valid
 LCC_RETURN wrapped_gctools__multiple_values_ensure_valid_core__T_mv (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_mv> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = gctools ::gctools__multiple_values_ensure_valid(a0._v);
     return ret.as_return_type();
    }
// Generating code for gctools::gctools__NextUnshiftedStampValue
 LCC_RETURN wrapped_gctools__NextUnshiftedStampValue_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    Fixnum ret = gctools ::gctools__NextUnshiftedStampValue();
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__nextStampValue
 LCC_RETURN wrapped_gctools__nextStampValue_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    Fixnum ret = gctools ::gctools__nextStampValue();
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for snapshotSaveLoad::gctools__test_thread_pool
 LCC_RETURN wrapped_gctools__test_thread_pool_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    snapshotSaveLoad ::gctools__test_thread_pool();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__dump_stamp_info
 LCC_RETURN wrapped_gctools__dump_stamp_info_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__dump_stamp_info(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__object_size
 LCC_RETURN wrapped_gctools__object_size_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = gctools ::gctools__object_size(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__unwind_time_nanoseconds
 LCC_RETURN wrapped_gctools__unwind_time_nanoseconds_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Integer_sp ret = gctools ::gctools__unwind_time_nanoseconds();
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__thread_local_cleanup
 LCC_RETURN wrapped_gctools__thread_local_cleanup_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__thread_local_cleanup();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__configuration
 LCC_RETURN wrapped_gctools__configuration_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__configuration();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__debug_allocations
 LCC_RETURN wrapped_gctools__debug_allocations_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__debug_allocations(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__get_stamp_name_map
 LCC_RETURN wrapped_gctools__get_stamp_name_map_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = gctools ::gctools__get_stamp_name_map();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__register_stamp_name
 LCC_RETURN wrapped_gctools__register_stamp_name_const_std__string_size_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    gctools ::gctools__register_stamp_name(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__garbage_collect
 LCC_RETURN wrapped_gctools__garbage_collect_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__garbage_collect();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__vtable_address
 LCC_RETURN wrapped_gctools__vtable_address_core__General_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::General_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::gctools__vtable_address(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__object_address
 LCC_RETURN wrapped_gctools__object_address_core__General_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::General_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::gctools__object_address(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__memory_profile_status
 LCC_RETURN wrapped_gctools__memory_profile_status_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    auto ret = gctools ::gctools__memory_profile_status();
     return ret.as_return_type();
    }
// Generating code for gctools::gctools__definalize
 LCC_RETURN wrapped_gctools__definalize_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__definalize(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__invoke_finalizers
 LCC_RETURN wrapped_gctools__invoke_finalizers_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__invoke_finalizers();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__finalizers
 LCC_RETURN wrapped_gctools__finalizers_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::gctools__finalizers(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__finalize
 LCC_RETURN wrapped_gctools__finalize_core__T_spcore__Function_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    gctools ::gctools__finalize(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__save_lisp_and_continue
 LCC_RETURN wrapped_gctools__save_lisp_and_continue_core__String_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    gctools ::gctools__save_lisp_and_continue(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__save_lisp_and_die
 LCC_RETURN wrapped_gctools__save_lisp_and_die_core__String_spboolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    gctools ::gctools__save_lisp_and_die(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__memory_test
 LCC_RETURN wrapped_gctools__memory_test_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = gctools ::gctools__memory_test();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for gctools::cl__room
 LCC_RETURN wrapped_cl__room_core__Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::cl__room(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__alloc_pattern_end
 LCC_RETURN wrapped_gctools__alloc_pattern_end_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Symbol_sp ret = gctools ::gctools__alloc_pattern_end();
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__alloc_pattern_begin
 LCC_RETURN wrapped_gctools__alloc_pattern_begin_core__Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__alloc_pattern_begin(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__monitor_allocations
 LCC_RETURN wrapped_gctools__monitor_allocations_boolcore__Fixnum_spcore__Fixnum_spcore__Fixnum_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<bool> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Fixnum_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    gctools ::gctools__monitor_allocations(a0._v,a1._v,a2._v,a3._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::core__inherits_from_instance
 LCC_RETURN wrapped_core__inherits_from_instance_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = gctools ::core__inherits_from_instance(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__instance_stamp_set
 LCC_RETURN wrapped_core__instance_stamp_set_core__T_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    gctools ::core__instance_stamp_set(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::core__stamps_adjacent_p
 LCC_RETURN wrapped_core__stamps_adjacent_p_size_tsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = gctools ::core__stamps_adjacent_p(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__instance_tagged_pointer
 LCC_RETURN wrapped_core__instance_tagged_pointer_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::core__instance_tagged_pointer(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__instance_stamp
 LCC_RETURN wrapped_core__instance_stamp_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::core__instance_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__shift_stamp_for_compiled_code
 LCC_RETURN wrapped_core__shift_stamp_for_compiled_code_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = gctools ::core__shift_stamp_for_compiled_code(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__stamp_index
 LCC_RETURN wrapped_core__stamp_index_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = gctools ::core__stamp_index(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__header_value
 LCC_RETURN wrapped_core__header_value_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::core__header_value(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__header_stamp
 LCC_RETURN wrapped_core__header_stamp_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::core__header_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__next_unused_kind
 LCC_RETURN wrapped_core__next_unused_kind_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = gctools ::core__next_unused_kind();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__bytes_allocated
 LCC_RETURN wrapped_gctools__bytes_allocated_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = gctools ::gctools__bytes_allocated();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__deallocate_unmanaged_instance
 LCC_RETURN wrapped_gctools__deallocate_unmanaged_instance_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__deallocate_unmanaged_instance(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__change_sigchld_sigport_handlers
 LCC_RETURN wrapped_gctools__change_sigchld_sigport_handlers_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::gctools__change_sigchld_sigport_handlers();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__thread_local_unwind_counter
 LCC_RETURN wrapped_gctools__thread_local_unwind_counter_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = gctools ::gctools__thread_local_unwind_counter();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__bootstrap_kind_p
 LCC_RETURN wrapped_gctools__bootstrap_kind_p_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = gctools ::gctools__bootstrap_kind_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__bootstrap_kind_symbols
 LCC_RETURN wrapped_gctools__bootstrap_kind_symbols_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Cons_sp ret = gctools ::gctools__bootstrap_kind_symbols();
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__max_bootstrap_kinds
 LCC_RETURN wrapped_gctools__max_bootstrap_kinds_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = gctools ::gctools__max_bootstrap_kinds();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__discriminating_function_compilation_seconds
 LCC_RETURN wrapped_gctools__discriminating_function_compilation_seconds_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    double ret = gctools ::gctools__discriminating_function_compilation_seconds();
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__accumulate_discriminating_function_compilation_seconds
 LCC_RETURN wrapped_gctools__accumulate_discriminating_function_compilation_seconds_double (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__accumulate_discriminating_function_compilation_seconds(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::core__signal_code_alist
 LCC_RETURN wrapped_core__signal_code_alist_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = gctools ::core__signal_code_alist();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__fe_restore_except
 LCC_RETURN wrapped_core__fe_restore_except_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = gctools ::core__fe_restore_except(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__fe_get_except
 LCC_RETURN wrapped_core__fe_get_except_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = gctools ::core__fe_get_except();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__fe_disable_except
 LCC_RETURN wrapped_core__fe_disable_except_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = gctools ::core__fe_disable_except(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__fe_enable_except
 LCC_RETURN wrapped_core__fe_enable_except_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = gctools ::core__fe_enable_except(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__wait_for_user_signal
 LCC_RETURN wrapped_gctools__wait_for_user_signal_const_std__string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools ::gctools__wait_for_user_signal(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for gctools::core__check_pending_interrupts
 LCC_RETURN wrapped_core__check_pending_interrupts_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gctools ::core__check_pending_interrupts();
     return Values0<core::T_O>();
    }
// Generating code for gctools::gctools__size_of_stamp_field_layout_table
 LCC_RETURN wrapped_gctools__size_of_stamp_field_layout_table_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    Fixnum ret = gctools ::gctools__size_of_stamp_field_layout_table();
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for gctools::gctools__thread_local_unwinds
 LCC_RETURN wrapped_gctools__thread_local_unwinds_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = gctools ::gctools__thread_local_unwinds();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__dynamic_usage
 LCC_RETURN wrapped_core__dynamic_usage_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = gctools ::core__dynamic_usage();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for gctools::core__dynamic_space_size
 LCC_RETURN wrapped_core__dynamic_space_size_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = gctools ::core__dynamic_space_size();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for clbind::clbind__dump_cast_graph
 LCC_RETURN wrapped_clbind__dump_cast_graph_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clbind ::clbind__dump_cast_graph(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for serveEvent::serve_event_internal__ll_serveEventWithTimeout
 LCC_RETURN wrapped_serve_event_internal__ll_serveEventWithTimeout_clasp_ffi__ForeignData_spclasp_ffi__ForeignData_spintdouble (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<clasp_ffi::ForeignData_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<double> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = serveEvent ::serve_event_internal__ll_serveEventWithTimeout(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for serveEvent::serve_event_internal__ll_serveEventNoTimeout
 LCC_RETURN wrapped_serve_event_internal__ll_serveEventNoTimeout_clasp_ffi__ForeignData_spclasp_ffi__ForeignData_spint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<clasp_ffi::ForeignData_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = serveEvent ::serve_event_internal__ll_serveEventNoTimeout(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for serveEvent::serve_event_internal__ll_fdset_size
 LCC_RETURN wrapped_serve_event_internal__ll_fdset_size_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = serveEvent ::serve_event_internal__ll_fdset_size();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for serveEvent::serve_event_internal__ll_fd_isset
 LCC_RETURN wrapped_serve_event_internal__ll_fd_isset_intclasp_ffi__ForeignData_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<clasp_ffi::ForeignData_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = serveEvent ::serve_event_internal__ll_fd_isset(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for serveEvent::serve_event_internal__ll_fd_set
 LCC_RETURN wrapped_serve_event_internal__ll_fd_set_intclasp_ffi__ForeignData_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<clasp_ffi::ForeignData_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    serveEvent ::serve_event_internal__ll_fd_set(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for serveEvent::serve_event_internal__ll_fd_zero
 LCC_RETURN wrapped_serve_event_internal__ll_fd_zero_clasp_ffi__ForeignData_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    serveEvent ::serve_event_internal__ll_fd_zero(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for sockets::sockets_internal__do_select
 LCC_RETURN wrapped_sockets_internal__do_select_core__T_spunsigned_intcore__Pointer_spint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<unsigned int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Pointer_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    int ret = sockets ::sockets_internal__do_select(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__get_host_name
 LCC_RETURN wrapped_sockets_internal__get_host_name_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = sockets ::sockets_internal__get_host_name();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__fdset_isset
 LCC_RETURN wrapped_sockets_internal__fdset_isset_gc__Fixnumcore__Pointer_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<gc::Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = sockets ::sockets_internal__fdset_isset(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__fdset_clr
 LCC_RETURN wrapped_sockets_internal__fdset_clr_gc__Fixnumcore__Pointer_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<gc::Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    sockets ::sockets_internal__fdset_clr(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for sockets::sockets_internal__fdset_set
 LCC_RETURN wrapped_sockets_internal__fdset_set_gc__Fixnumcore__Pointer_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<gc::Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    sockets ::sockets_internal__fdset_set(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for sockets::sockets_internal__fdset_zero
 LCC_RETURN wrapped_sockets_internal__fdset_zero_core__Pointer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    sockets ::sockets_internal__fdset_zero(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for sockets::sockets_internal__alloc_atomic_sizeof_fd_set
 LCC_RETURN wrapped_sockets_internal__alloc_atomic_sizeof_fd_set_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    void* ret = sockets ::sockets_internal__alloc_atomic_sizeof_fd_set();
     return translate::to_object<void*>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__fd_setsize
 LCC_RETURN wrapped_sockets_internal__fd_setsize_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    gc::Fixnum ret = sockets ::sockets_internal__fd_setsize();
     return translate::to_object<gc::Fixnum>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__errno
 LCC_RETURN wrapped_sockets_internal__errno_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = sockets ::sockets_internal__errno();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__shutdown
 LCC_RETURN wrapped_sockets_internal__shutdown_intint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = sockets ::sockets_internal__shutdown(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_setSockoptLinger
 LCC_RETURN wrapped_sockets_internal__ll_setSockoptLinger_intintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    bool ret = sockets ::sockets_internal__ll_setSockoptLinger(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_setSockoptTimeval
 LCC_RETURN wrapped_sockets_internal__ll_setSockoptTimeval_intintintdouble (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<double> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    bool ret = sockets ::sockets_internal__ll_setSockoptTimeval(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_setSockoptBool
 LCC_RETURN wrapped_sockets_internal__ll_setSockoptBool_intintintbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    bool ret = sockets ::sockets_internal__ll_setSockoptBool(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_setSockoptInt
 LCC_RETURN wrapped_sockets_internal__ll_setSockoptInt_intintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    bool ret = sockets ::sockets_internal__ll_setSockoptInt(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getSockoptLinger
 LCC_RETURN wrapped_sockets_internal__ll_getSockoptLinger_intintint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Integer_sp ret = sockets ::sockets_internal__ll_getSockoptLinger(a0._v,a1._v,a2._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getSockoptTimeval
 LCC_RETURN wrapped_sockets_internal__ll_getSockoptTimeval_intintint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::DoubleFloat_sp ret = sockets ::sockets_internal__ll_getSockoptTimeval(a0._v,a1._v,a2._v);
     return translate::to_object<core::DoubleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getSockoptBool
 LCC_RETURN wrapped_sockets_internal__ll_getSockoptBool_intintint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = sockets ::sockets_internal__ll_getSockoptBool(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getSockoptInt
 LCC_RETURN wrapped_sockets_internal__ll_getSockoptInt_intintint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Integer_sp ret = sockets ::sockets_internal__ll_getSockoptInt(a0._v,a1._v,a2._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_strerror_errno
 LCC_RETURN wrapped_sockets_internal__ll_strerror_errno_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::String_sp ret = sockets ::sockets_internal__ll_strerror_errno();
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_strerror
 LCC_RETURN wrapped_sockets_internal__ll_strerror_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = sockets ::sockets_internal__ll_strerror(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_autoCloseTwoWayStream
 LCC_RETURN wrapped_sockets_internal__ll_autoCloseTwoWayStream_core__AnsiStream_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::AnsiStream_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    sockets ::sockets_internal__ll_autoCloseTwoWayStream(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for sockets::sockets_internal__ll_dup
 LCC_RETURN wrapped_sockets_internal__ll_dup_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = sockets ::sockets_internal__ll_dup(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_setfNonBlockingMode
 LCC_RETURN wrapped_sockets_internal__ll_setfNonBlockingMode_intint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = sockets ::sockets_internal__ll_setfNonBlockingMode(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_nonBlockingMode
 LCC_RETURN wrapped_sockets_internal__ll_nonBlockingMode_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = sockets ::sockets_internal__ll_nonBlockingMode(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketPeername_localSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketPeername_localSocket_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = sockets ::sockets_internal__ll_socketPeername_localSocket(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketConnect_localSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketConnect_localSocket_intintconst_string_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const string&> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    int ret = sockets ::sockets_internal__ll_socketConnect_localSocket(a0._v,a1._v,a2._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketAccept_localSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketAccept_localSocket_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = sockets ::sockets_internal__ll_socketAccept_localSocket(a0._v);
     return ret.as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketBind_localSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketBind_localSocket_intconst_string_int (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    int ret = sockets ::sockets_internal__ll_socketBind_localSocket(a0._v,a1._v,a2._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketSendNoAddress
 LCC_RETURN wrapped_sockets_internal__ll_socketSendNoAddress_intcore__Vector_spintboolboolboolboolboolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<bool> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<bool> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<bool> a8 (core::T_sp((gc::Tagged)(in8)));
                     
    core::Integer_sp ret = sockets ::sockets_internal__ll_socketSendNoAddress(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketSendAddress
 LCC_RETURN wrapped_sockets_internal__ll_socketSendAddress_intcore__Vector_spintintintintintintboolboolboolboolboolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8,core::T_O* in9,core::T_O* in10,core::T_O* in11,core::T_O* in12,core::T_O* in13) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<int> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<int> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<int> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<bool> a8 (core::T_sp((gc::Tagged)(in8)));
                     translate::from_object<bool> a9 (core::T_sp((gc::Tagged)(in9)));
                     translate::from_object<bool> a10 (core::T_sp((gc::Tagged)(in10)));
                     translate::from_object<bool> a11 (core::T_sp((gc::Tagged)(in11)));
                     translate::from_object<bool> a12 (core::T_sp((gc::Tagged)(in12)));
                     translate::from_object<bool> a13 (core::T_sp((gc::Tagged)(in13)));
                     
    core::Integer_sp ret = sockets ::sockets_internal__ll_socketSendAddress(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v,a9._v,a10._v,a11._v,a12._v,a13._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketName
 LCC_RETURN wrapped_sockets_internal__ll_socketName_intcore__Vector_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = sockets ::sockets_internal__ll_socketName(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketPeername_inetSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketPeername_inetSocket_intcore__Vector_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = sockets ::sockets_internal__ll_socketPeername_inetSocket(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketConnect_inetSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketConnect_inetSocket_intintintintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<int> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    int ret = sockets ::sockets_internal__ll_socketConnect_inetSocket(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketAccept_inetSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketAccept_inetSocket_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = sockets ::sockets_internal__ll_socketAccept_inetSocket(a0._v);
     return ret.as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketBind_inetSocket
 LCC_RETURN wrapped_sockets_internal__ll_socketBind_inetSocket_intintintintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<int> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    int ret = sockets ::sockets_internal__ll_socketBind_inetSocket(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getProtocolByName
 LCC_RETURN wrapped_sockets_internal__ll_getProtocolByName_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = sockets ::sockets_internal__ll_getProtocolByName(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socketReceive
 LCC_RETURN wrapped_sockets_internal__ll_socketReceive_intcore__T_spintboolboolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    auto ret = sockets ::sockets_internal__ll_socketReceive(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return ret.as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getHostByAddress
 LCC_RETURN wrapped_sockets_internal__ll_getHostByAddress_core__Vector_spcore__T_spcore__T_spcore__T_spcore__T_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = sockets ::sockets_internal__ll_getHostByAddress(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getHostByName
 LCC_RETURN wrapped_sockets_internal__ll_getHostByName_const_string_core__T_spcore__Function_spcore__Function_spcore__Function_spcore__Function_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Function_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Function_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Function_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::Function_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = sockets ::sockets_internal__ll_getHostByName(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_getNameServiceErrorMessage
 LCC_RETURN wrapped_sockets_internal__ll_getNameServiceErrorMessage_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = sockets ::sockets_internal__ll_getNameServiceErrorMessage(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_get_name_service_h_errno
 LCC_RETURN wrapped_sockets_internal__ll_get_name_service_h_errno_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = sockets ::sockets_internal__ll_get_name_service_h_errno();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ll_socket_errno
 LCC_RETURN wrapped_sockets_internal__ll_socket_errno_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = sockets ::sockets_internal__ll_socket_errno();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__funcName
 LCC_RETURN wrapped_sockets_internal__funcName_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    auto ret = sockets ::sockets_internal__funcName();
     return ret.as_return_type();
    }
// Generating code for sockets::sockets_internal__ff_close
 LCC_RETURN wrapped_sockets_internal__ff_close_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = sockets ::sockets_internal__ff_close(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ff_listen
 LCC_RETURN wrapped_sockets_internal__ff_listen_intint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = sockets ::sockets_internal__ff_listen(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for sockets::sockets_internal__ff_socket
 LCC_RETURN wrapped_sockets_internal__ff_socket_intintint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    int ret = sockets ::sockets_internal__ff_socket(a0._v,a1._v,a2._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for llvmo::jit_lookup_t
 LCC_RETURN wrapped_jit_lookup_t_JITDylib_spconst_std__string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::JITDylib_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const std::string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = llvmo ::jit_lookup_t(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::jit_lookup
 LCC_RETURN wrapped_jit_lookup_JITDylib_spconst_std__string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::JITDylib_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const std::string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Pointer_sp ret = llvmo ::jit_lookup(a0._v,a1._v);
     return translate::to_object<core::Pointer_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::jit_module_to_dylib
 LCC_RETURN wrapped_jit_module_to_dylib_Module_spconst_std__string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const std::string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::JITDylib_sp ret = llvmo ::jit_module_to_dylib(a0._v,a1._v);
     return translate::to_object<llvmo::JITDylib_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::cmp__compile_trampoline
 LCC_RETURN wrapped_cmp__compile_trampoline_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = llvmo ::cmp__compile_trampoline(a0._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::llvm_sys__clasp_jit
 LCC_RETURN wrapped_llvm_sys__clasp_jit_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo::ClaspJIT_sp ret = llvmo ::llvm_sys__clasp_jit();
     return translate::to_object<llvmo::ClaspJIT_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__viewCFG
 LCC_RETURN wrapped_llvm_sys__viewCFG_core__T_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__viewCFG(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::dump_function
 LCC_RETURN wrapped_dump_function_Function_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::dump_function(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::dump_module
 LCC_RETURN wrapped_dump_module_Module_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::dump_module(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__getOrCreateExternalGlobal
 LCC_RETURN wrapped_llvm_sys__getOrCreateExternalGlobal_llvmo__Module_spconst_string_llvmo__Type_spllvm__GlobalValue__LinkageTypes (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvmo::Type_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::GlobalValue::LinkageTypes> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvmo::GlobalVariable_sp ret = llvmo ::llvm_sys__getOrCreateExternalGlobal(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvmo::GlobalVariable_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__throwIfMismatchedStructureSizes
 LCC_RETURN wrapped_llvm_sys__throwIfMismatchedStructureSizes_core__Fixnum_spcore__Fixnum_spcore__Fixnum_spcore__Fixnum_spcore__Fixnum_spcore__Fixnum_spcore__Fixnum_spcore__T_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Fixnum_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::Fixnum_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::Fixnum_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<core::T_sp> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<core::T_sp> a8 (core::T_sp((gc::Tagged)(in8)));
                     
    llvmo ::llvm_sys__throwIfMismatchedStructureSizes(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__cxxDataStructuresInfo
 LCC_RETURN wrapped_llvm_sys__cxxDataStructuresInfo_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::llvm_sys__cxxDataStructuresInfo();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__tag_tests
 LCC_RETURN wrapped_llvm_sys__tag_tests_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::llvm_sys__tag_tests();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__mangleSymbolName
 LCC_RETURN wrapped_llvm_sys__mangleSymbolName_core__String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleBaseString_sp ret = llvmo ::llvm_sys__mangleSymbolName(a0._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__executable_and_libraries
 LCC_RETURN wrapped_llvm_sys__executable_and_libraries_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::llvm_sys__executable_and_libraries();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::codeEnd
 LCC_RETURN wrapped_codeEnd_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uintptr_t ret = llvmo ::codeEnd(a0._v);
     return translate::to_object<uintptr_t>::convert(ret).as_return_type();
    }
// Generating code for llvmo::codeStart
 LCC_RETURN wrapped_codeStart_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uintptr_t ret = llvmo ::codeStart(a0._v);
     return translate::to_object<uintptr_t>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__allObjectFileNames
 LCC_RETURN wrapped_llvm_sys__allObjectFileNames_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::llvm_sys__allObjectFileNames();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__make_code_block
 LCC_RETURN wrapped_llvm_sys__make_code_block_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::CodeBlock_sp ret = llvmo ::llvm_sys__make_code_block(a0._v);
     return translate::to_object<llvmo::CodeBlock_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::describe_code
 LCC_RETURN wrapped_describe_code_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo ::describe_code();
     return Values0<core::T_O>();
    }
// Generating code for llvmo::ext__generate_perf_map
 LCC_RETURN wrapped_ext__generate_perf_map_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo ::ext__generate_perf_map();
     return Values0<core::T_O>();
    }
// Generating code for llvmo::jit_code_entries
 LCC_RETURN wrapped_jit_code_entries_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::jit_code_entries();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::all_object_files
 LCC_RETURN wrapped_all_object_files_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = llvmo ::all_object_files();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::total_memory_allocated_for_object_files
 LCC_RETURN wrapped_total_memory_allocated_for_object_files_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = llvmo ::total_memory_allocated_for_object_files();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for llvmo::number_of_object_files
 LCC_RETURN wrapped_number_of_object_files_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = llvmo ::number_of_object_files();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for llvmo::release_object_files
 LCC_RETURN wrapped_release_object_files_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo ::release_object_files();
     return Values0<core::T_O>();
    }
// Generating code for llvmo::object_file_for_instruction_pointer
 LCC_RETURN wrapped_object_file_for_instruction_pointer_void_bool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<void*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::object_file_for_instruction_pointer(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::object_file_sectioned_address
 LCC_RETURN wrapped_object_file_sectioned_address_void_ObjectFile_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<void*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::ObjectFile_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::SectionedAddress_sp ret = llvmo ::object_file_sectioned_address(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::SectionedAddress_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::identify_code_or_library
 LCC_RETURN wrapped_identify_code_or_library_gctools__clasp_ptr_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<gctools::clasp_ptr_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = llvmo ::identify_code_or_library(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::code_literal_address
 LCC_RETURN wrapped_code_literal_address_ObjectFile_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::ObjectFile_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = llvmo ::code_literal_address(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::code_literal_ref
 LCC_RETURN wrapped_code_literal_ref_ObjectFile_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::ObjectFile_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = llvmo ::code_literal_ref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::code_literals_length
 LCC_RETURN wrapped_code_literals_length_ObjectFile_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::ObjectFile_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = llvmo ::code_literals_length(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__set_current_debug_types
 LCC_RETURN wrapped_llvm_sys__set_current_debug_types_core__List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__set_current_debug_types(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__optimizeModule
 LCC_RETURN wrapped_llvm_sys__optimizeModule_llvm__Module_int (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Module*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__optimizeModule(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__removeAlwaysInlineFunctions
 LCC_RETURN wrapped_llvm_sys__removeAlwaysInlineFunctions_llvm__Module_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Module*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__removeAlwaysInlineFunctions(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__remove_useless_global_ctors
 LCC_RETURN wrapped_llvm_sys__remove_useless_global_ctors_llvmo__Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__remove_useless_global_ctors(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__lookup_jit_symbol_info
 LCC_RETURN wrapped_llvm_sys__lookup_jit_symbol_info_void_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<void*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = llvmo ::llvm_sys__lookup_jit_symbol_info(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Do nothing yet for function InitializeNativeTarget of type EXPOSE-EXTERN-DEFUN
// Generating code for llvmo::TargetRegistryLookupTarget_string
 LCC_RETURN wrapped_TargetRegistryLookupTarget_string_const_std__string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = llvmo ::TargetRegistryLookupTarget_string(a0._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::TargetRegistryLookupTarget
 LCC_RETURN wrapped_TargetRegistryLookupTarget_const_std__string_Triple_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::Triple_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::TargetRegistryLookupTarget(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::llvm_sys__accumulate_llvm_usage_seconds
 LCC_RETURN wrapped_llvm_sys__accumulate_llvm_usage_seconds_double (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__accumulate_llvm_usage_seconds(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::VectorType_O::get
 LCC_RETURN wrapped_VectorType_O__get_Type_spunsignedbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Type_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<unsigned> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::VectorType_sp ret = llvmo ::VectorType_O::get(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::VectorType_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::PointerType_O::get
 LCC_RETURN wrapped_PointerType_O__get_Type_spuint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Type_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<uint> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::PointerType_sp ret = llvmo ::PointerType_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::PointerType_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__getNumElements
 LCC_RETURN wrapped_llvm_sys__getNumElements_Type_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Type_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = llvmo ::llvm_sys__getNumElements(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for llvmo::ArrayType_O::get
 LCC_RETURN wrapped_ArrayType_O__get_Type_spuint64_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Type_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<uint64_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::ArrayType_sp ret = llvmo ::ArrayType_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::ArrayType_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::indexValid
 LCC_RETURN wrapped_indexValid_Type_spunsigned (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Type_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<unsigned> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = llvmo ::indexValid(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for llvmo::StructType_O::get
 LCC_RETURN wrapped_StructType_O__get_LLVMContext_spcore__T_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::StructType_sp ret = llvmo ::StructType_O::get(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::StructType_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::StructType_O::make
 LCC_RETURN wrapped_StructType_O__make_LLVMContext_spcore__T_spllvm__StringRefcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::StringRef> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvmo::StructType_sp ret = llvmo ::StructType_O::make(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvmo::StructType_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__function_type_vararg_p
 LCC_RETURN wrapped_llvm_sys__function_type_vararg_p_llvmo__FunctionType_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::FunctionType_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = llvmo ::llvm_sys__function_type_vararg_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__function_type_param_types
 LCC_RETURN wrapped_llvm_sys__function_type_param_types_llvmo__FunctionType_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::FunctionType_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = llvmo ::llvm_sys__function_type_param_types(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::FunctionType_O::get
 LCC_RETURN wrapped_FunctionType_O__get_llvm__Type_core__T_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = llvmo ::FunctionType_O::get(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt128Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt128Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt128Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt64Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt64Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt64Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt32Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt32Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt32Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt16Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt16Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt16Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt8Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt8Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt8Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getInt1Ty
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getInt1Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::IntegerType* ret = llvm::Type ::getInt1Ty(a0._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getIntNTy
// return-type -> "llvm::IntegerType*"
// arg-types -> ("llvm::LLVMContext&" "unsigned")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getIntNTy_llvm__LLVMContext_unsigned (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<unsigned> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::IntegerType* ret = llvm::Type ::getIntNTy(a0._v,a1._v);
     return translate::to_object<llvm::IntegerType*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getMetadataTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getMetadataTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getMetadataTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getFP128Ty
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getFP128Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getFP128Ty(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getX86_FP80Ty
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getX86_FP80Ty_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getX86_FP80Ty(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getDoubleTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getDoubleTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getDoubleTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getFloatTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getFloatTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getFloatTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getBFloatTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getBFloatTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getBFloatTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getHalfTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getHalfTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getHalfTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvm::Type::getVoidTy
// return-type -> "llvm::Type*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getVoidTy_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Type* ret = llvm::Type ::getVoidTy(a0._v);
     return translate::to_object<llvm::Type*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__BasicBlockCreate
 LCC_RETURN wrapped_llvm_sys__BasicBlockCreate_llvm__LLVMContext_const_llvm__Twine_llvm__Function_llvm__BasicBlock_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const llvm::Twine&> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Function*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::BasicBlock*> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::BasicBlock* ret = llvmo ::llvm_sys__BasicBlockCreate(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::BasicBlock*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__FunctionCreate
 LCC_RETURN wrapped_llvm_sys__FunctionCreate_llvm__FunctionType_llvm__GlobalValue__LinkageTypescore__String_spllvm__Module_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::FunctionType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::GlobalValue::LinkageTypes> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::String_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Module*> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvmo::Function_sp ret = llvmo ::llvm_sys__FunctionCreate(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvmo::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::MDString_O::get
 LCC_RETURN wrapped_MDString_O__get_LLVMContext_spcore__String_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::MDString_sp ret = llvmo ::MDString_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::MDString_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::MDNode_O::get
 LCC_RETURN wrapped_MDNode_O__get_LLVMContext_spcore__List_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::MDNode_sp ret = llvmo ::MDNode_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::MDNode_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateInBoundsGEPType
 LCC_RETURN wrapped_llvm_sys__CreateInBoundsGEPType_llvmo__IRBuilderBase_O__ExternalType_llvm__Type_llvm__Value_llvm__ArrayRef_llvm__Value__const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Type*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::ArrayRef<llvm::Value*>> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateInBoundsGEPType(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateXor_value_value
 LCC_RETURN wrapped_llvm_sys__CreateXor_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateXor_value_value(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateOr_value_apint
 LCC_RETURN wrapped_llvm_sys__CreateOr_value_apint_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__APInt_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::APInt&> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateOr_value_apint(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateOr_value_value
 LCC_RETURN wrapped_llvm_sys__CreateOr_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateOr_value_value(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateAnd_value_uint64
 LCC_RETURN wrapped_llvm_sys__CreateAnd_value_uint64_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_uint64_tconst_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<uint64_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateAnd_value_uint64(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateAnd_value_apint
 LCC_RETURN wrapped_llvm_sys__CreateAnd_value_apint_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__APInt_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::APInt&> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateAnd_value_apint(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateAnd_value_value
 LCC_RETURN wrapped_llvm_sys__CreateAnd_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateAnd_value_value(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateAShr_value_apint
 LCC_RETURN wrapped_llvm_sys__CreateAShr_value_apint_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__APInt_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::APInt&> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateAShr_value_apint(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateAShr_value_value
 LCC_RETURN wrapped_llvm_sys__CreateAShr_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateAShr_value_value(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateLShr_value_uint64
 LCC_RETURN wrapped_llvm_sys__CreateLShr_value_uint64_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_unsigned_longconst_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<unsigned long> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateLShr_value_uint64(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateLShr_value_value
 LCC_RETURN wrapped_llvm_sys__CreateLShr_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateLShr_value_value(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateShl_value_uint64
 LCC_RETURN wrapped_llvm_sys__CreateShl_value_uint64_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_uint64_tconst_llvm__Twine_boolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<uint64_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateShl_value_uint64(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateShl_value_value
 LCC_RETURN wrapped_llvm_sys__CreateShl_value_value_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_boolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateShl_value_value(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateIsNotNull
 LCC_RETURN wrapped_llvm_sys__CreateIsNotNull_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::Twine&> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateIsNotNull(a0._v,a1._v,a2._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateFPExt
 LCC_RETURN wrapped_llvm_sys__CreateFPExt_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateFPExt(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateFPTrunc
 LCC_RETURN wrapped_llvm_sys__CreateFPTrunc_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateFPTrunc(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateSIToFP
 LCC_RETURN wrapped_llvm_sys__CreateSIToFP_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateSIToFP(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__CreateUIToFP
 LCC_RETURN wrapped_llvm_sys__CreateUIToFP_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::llvm_sys__CreateUIToFP(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateCondBr
 LCC_RETURN wrapped_CreateCondBr_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__BasicBlock_llvm__BasicBlock_llvm__MDNode_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::BasicBlock*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::BasicBlock*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::MDNode*> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::BranchInst* ret = llvmo ::CreateCondBr(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::BranchInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateAdd
 LCC_RETURN wrapped_CreateAdd_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_boolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::CreateAdd(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateRet
 LCC_RETURN wrapped_CreateRet_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::ReturnInst* ret = llvmo ::CreateRet(a0._v,a1._v);
     return translate::to_object<llvm::ReturnInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateRetVoid
 LCC_RETURN wrapped_CreateRetVoid_llvmo__IRBuilderBase_O__ExternalType_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::ReturnInst* ret = llvmo ::CreateRetVoid(a0._v);
     return translate::to_object<llvm::ReturnInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateBr
 LCC_RETURN wrapped_CreateBr_llvmo__IRBuilderBase_O__ExternalType_llvm__BasicBlock_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::BasicBlock*> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::BranchInst* ret = llvmo ::CreateBr(a0._v,a1._v);
     return translate::to_object<llvm::BranchInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateSwitch
 LCC_RETURN wrapped_CreateSwitch_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__BasicBlock_unsignedllvm__MDNode_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::BasicBlock*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<unsigned> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::MDNode*> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::SwitchInst* ret = llvmo ::CreateSwitch(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::SwitchInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateUnreachable
 LCC_RETURN wrapped_CreateUnreachable_llvmo__IRBuilderBase_O__ExternalType_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::UnreachableInst* ret = llvmo ::CreateUnreachable(a0._v);
     return translate::to_object<llvm::UnreachableInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFAdd
 LCC_RETURN wrapped_CreateFAdd_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateFAdd(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateSub
 LCC_RETURN wrapped_CreateSub_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_boolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::CreateSub(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFSub
 LCC_RETURN wrapped_CreateFSub_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateFSub(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateMul
 LCC_RETURN wrapped_CreateMul_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_boolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::CreateMul(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFMul
 LCC_RETURN wrapped_CreateFMul_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateFMul(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateUDiv
 LCC_RETURN wrapped_CreateUDiv_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateUDiv(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateSDiv
 LCC_RETURN wrapped_CreateSDiv_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateSDiv(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFDiv
 LCC_RETURN wrapped_CreateFDiv_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MDNode*> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateFDiv(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateURem
 LCC_RETURN wrapped_CreateURem_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateURem(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateSRem
 LCC_RETURN wrapped_CreateSRem_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateSRem(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateNeg
 LCC_RETURN wrapped_CreateNeg_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__Twine_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::Twine&> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateNeg(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFNeg
 LCC_RETURN wrapped_CreateFNeg_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::Twine&> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::MDNode*> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateFNeg(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateNot
 LCC_RETURN wrapped_CreateNot_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const llvm::Twine&> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvm::Value* ret = llvmo ::CreateNot(a0._v,a1._v,a2._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateAlloca
 LCC_RETURN wrapped_CreateAlloca_llvmo__IRBuilderBase_O__ExternalType_llvm__Type_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Type*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::AllocaInst* ret = llvmo ::CreateAlloca(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::AllocaInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateFence
 LCC_RETURN wrapped_CreateFence_llvmo__IRBuilderBase_O__ExternalType_llvm__AtomicOrderingllvm__SyncScope__IDconst_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::AtomicOrdering> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::SyncScope::ID> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::FenceInst* ret = llvmo ::CreateFence(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::FenceInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateAtomicCmpXchg
 LCC_RETURN wrapped_CreateAtomicCmpXchg_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_llvm__Value_llvm__MaybeAlignllvm__AtomicOrderingllvm__AtomicOrderingllvm__SyncScope__ID (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Value*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MaybeAlign> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::AtomicOrdering> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<llvm::AtomicOrdering> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<llvm::SyncScope::ID> a7 (core::T_sp((gc::Tagged)(in7)));
                     
    llvm::AtomicCmpXchgInst* ret = llvmo ::CreateAtomicCmpXchg(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v);
     return translate::to_object<llvm::AtomicCmpXchgInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateAtomicRMW
 LCC_RETURN wrapped_CreateAtomicRMW_llvmo__IRBuilderBase_O__ExternalType_llvm__AtomicRMWInst__BinOpllvm__Value_llvm__Value_llvm__MaybeAlignllvm__AtomicOrderingllvm__SyncScope__ID (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::AtomicRMWInst::BinOp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Value*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<llvm::MaybeAlign> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::AtomicOrdering> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<llvm::SyncScope::ID> a6 (core::T_sp((gc::Tagged)(in6)));
                     
    llvm::AtomicRMWInst* ret = llvmo ::CreateAtomicRMW(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v);
     return translate::to_object<llvm::AtomicRMWInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateConstInBoundsGEP2_32
 LCC_RETURN wrapped_CreateConstInBoundsGEP2_32_llvmo__IRBuilderBase_O__ExternalType_llvm__Type_llvm__Value_unsignedunsignedconst_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Type*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<unsigned> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<unsigned> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<const llvm::Twine&> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::CreateConstInBoundsGEP2_32(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateZExtOrBitCast
 LCC_RETURN wrapped_CreateZExtOrBitCast_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateZExtOrBitCast(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateTruncOrBitCast
 LCC_RETURN wrapped_CreateTruncOrBitCast_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateTruncOrBitCast(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreatePointerCast
 LCC_RETURN wrapped_CreatePointerCast_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Type*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreatePointerCast(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateICmp
 LCC_RETURN wrapped_CreateICmp_llvmo__IRBuilderBase_O__ExternalType_llvm__CmpInst__Predicatellvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::CmpInst::Predicate> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Value*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateICmp(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreatePHI
 LCC_RETURN wrapped_CreatePHI_llvmo__IRBuilderBase_O__ExternalType_llvm__Type_unsignedconst_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Type*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<unsigned> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::PHINode* ret = llvmo ::CreatePHI(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::PHINode*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateCall
 LCC_RETURN wrapped_CreateCall_llvmo__IRBuilderBase_O__ExternalType_llvm__FunctionType_llvm__Value_llvm__ArrayRef_llvm__Value__const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::FunctionType*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::ArrayRef<llvm::Value*>> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::MDNode*> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::CallInst* ret = llvmo ::CreateCall(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::CallInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateExtractElement
 LCC_RETURN wrapped_CreateExtractElement_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<const llvm::Twine&> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    llvm::Value* ret = llvmo ::CreateExtractElement(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateInsertElement
 LCC_RETURN wrapped_CreateInsertElement_llvmo__IRBuilderBase_O__ExternalType_llvm__Value_llvm__Value_llvm__Value_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Value*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateInsertElement(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateCast
 LCC_RETURN wrapped_CreateCast_llvmo__IRBuilderBase_O__ExternalType_llvm__Instruction__CastOpsllvm__Value_llvm__Type_const_llvm__Twine_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Instruction::CastOps> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Type*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvm::Value* ret = llvmo ::CreateCast(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::CreateBinOp
 LCC_RETURN wrapped_CreateBinOp_llvmo__IRBuilderBase_O__ExternalType_llvm__Instruction__BinaryOpsllvm__Value_llvm__Value_const_llvm__Twine_llvm__MDNode_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Instruction::BinaryOps> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::Value*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::Value*> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<const llvm::Twine&> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::MDNode*> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvm::Value* ret = llvmo ::CreateBinOp(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvm::Value*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::SetInsertPointInstruction
 LCC_RETURN wrapped_SetInsertPointInstruction_llvmo__IRBuilderBase_O__ExternalType_llvm__Instruction_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::IRBuilderBase_O::ExternalType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Instruction*> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::SetInsertPointInstruction(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::addIncoming
 LCC_RETURN wrapped_addIncoming_llvm__PHINode_llvm__Value_llvm__BasicBlock_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::PHINode*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Value*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::BasicBlock*> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo ::addIncoming(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::IRBuilder_O::make
 LCC_RETURN wrapped_IRBuilder_O__make_LLVMContext_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::IRBuilder_sp ret = llvmo ::IRBuilder_O::make(a0._v);
     return translate::to_object<llvmo::IRBuilder_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::toInteger
 LCC_RETURN wrapped_toInteger_APInt_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::APInt_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = llvmo ::toInteger(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__apint_to_string
 LCC_RETURN wrapped_llvm_sys__apint_to_string_APInt_spintbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::APInt_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    string ret = llvmo ::llvm_sys__apint_to_string(a0._v,a1._v,a2._v);
     return translate::to_object<string>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APInt_O::makeAPInt64
 LCC_RETURN wrapped_APInt_O__makeAPInt64_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::APInt_sp ret = llvmo ::APInt_O::makeAPInt64(a0._v);
     return translate::to_object<llvmo::APInt_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APInt_O::makeAPInt32
 LCC_RETURN wrapped_APInt_O__makeAPInt32_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::APInt_sp ret = llvmo ::APInt_O::makeAPInt32(a0._v);
     return translate::to_object<llvmo::APInt_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APInt_O::makeAPIntWidth
 LCC_RETURN wrapped_APInt_O__makeAPIntWidth_core__Integer_spuintbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<uint> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::APInt_sp ret = llvmo ::APInt_O::makeAPIntWidth(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::APInt_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APInt_O::makeAPInt1
 LCC_RETURN wrapped_APInt_O__makeAPInt1_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::APInt_sp ret = llvmo ::APInt_O::makeAPInt1(a0._v);
     return translate::to_object<llvmo::APInt_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APFloat_O::makeAPFloatDouble
 LCC_RETURN wrapped_APFloat_O__makeAPFloatDouble_core__DoubleFloat_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DoubleFloat_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::APFloat_sp ret = llvmo ::APFloat_O::makeAPFloatDouble(a0._v);
     return translate::to_object<llvmo::APFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::APFloat_O::makeAPFloatFloat
 LCC_RETURN wrapped_APFloat_O__makeAPFloatFloat_core__SingleFloat_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SingleFloat_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::APFloat_sp ret = llvmo ::APFloat_O::makeAPFloatFloat(a0._v);
     return translate::to_object<llvmo::APFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantPointerNull::get
// return-type -> "llvm::ConstantPointerNull*"
// arg-types -> ("llvm::PointerType*")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__PointerType_ (core::T_O* in0) {
    
    translate::from_object<llvm::PointerType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::ConstantPointerNull* ret = llvm::ConstantPointerNull ::get(a0._v);
     return translate::to_object<llvm::ConstantPointerNull*>::convert(ret).as_return_type();
    }
// Generating code for llvm::UndefValue::get
// return-type -> "llvm::UndefValue*"
// arg-types -> ("llvm::Type*")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__Type_ (core::T_O* in0) {
    
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::UndefValue* ret = llvm::UndefValue ::get(a0._v);
     return translate::to_object<llvm::UndefValue*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantStruct::get
// return-type -> "llvm::Constant*"
// arg-types -> ("llvm::StructType*" "llvm::ArrayRef<llvm::Constant*>")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__StructType_llvm__ArrayRef_llvm__Constant__ (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::StructType*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::ArrayRef<llvm::Constant*>> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::Constant* ret = llvm::ConstantStruct ::get(a0._v,a1._v);
     return translate::to_object<llvm::Constant*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantInt::getFalse
// return-type -> "llvm::ConstantInt*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getFalse_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::ConstantInt* ret = llvm::ConstantInt ::getFalse(a0._v);
     return translate::to_object<llvm::ConstantInt*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantInt::getTrue
// return-type -> "llvm::ConstantInt*"
// arg-types -> ("llvm::LLVMContext&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_getTrue_llvm__LLVMContext_ (core::T_O* in0) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::ConstantInt* ret = llvm::ConstantInt ::getTrue(a0._v);
     return translate::to_object<llvm::ConstantInt*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantInt::get
// return-type -> "llvm::ConstantInt*"
// arg-types -> ("llvm::LLVMContext&" "const llvm::APInt&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__LLVMContext_const_llvm__APInt_ (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const llvm::APInt&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::ConstantInt* ret = llvm::ConstantInt ::get(a0._v,a1._v);
     return translate::to_object<llvm::ConstantInt*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantFP::get
// return-type -> "llvm::Constant*"
// arg-types -> ("llvm::Type*" "llvm::StringRef")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__Type_llvm__StringRef (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::StringRef> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::Constant* ret = llvm::ConstantFP ::get(a0._v,a1._v);
     return translate::to_object<llvm::Constant*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantFP::get
// return-type -> "llvm::Constant*"
// arg-types -> ("llvm::Type*" "double")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__Type_double (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<double> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::Constant* ret = llvm::ConstantFP ::get(a0._v,a1._v);
     return translate::to_object<llvm::Constant*>::convert(ret).as_return_type();
    }
// Generating code for llvm::ConstantFP::get
// return-type -> "llvm::ConstantFP*"
// arg-types -> ("llvm::LLVMContext&" "const llvm::APFloat&")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_get_llvm__LLVMContext_const_llvm__APFloat_ (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const llvm::APFloat&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvm::ConstantFP* ret = llvm::ConstantFP ::get(a0._v,a1._v);
     return translate::to_object<llvm::ConstantFP*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__insert_alloca_before_terminator
 LCC_RETURN wrapped_llvm_sys__insert_alloca_before_terminator_llvm__Type_const_llvm__Twine_llvm__BasicBlock_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const llvm::Twine&> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::BasicBlock*> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvm::AllocaInst* ret = llvmo ::llvm_sys__insert_alloca_before_terminator(a0._v,a1._v,a2._v);
     return translate::to_object<llvm::AllocaInst*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__call_or_invoke_getArgumentList
 LCC_RETURN wrapped_llvm_sys__call_or_invoke_getArgumentList_CallBase_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::CallBase_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = llvmo ::llvm_sys__call_or_invoke_getArgumentList(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__replace_call
 LCC_RETURN wrapped_llvm_sys__replace_call_llvm__Function_llvm__Instruction_llvm__ArrayRef_llvm__Value__ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Function*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Instruction*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::ArrayRef<llvm::Value*>> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvm::Instruction* ret = llvmo ::llvm_sys__replace_call(a0._v,a1._v,a2._v);
     return translate::to_object<llvm::Instruction*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__instruction_getNextNonDebugInstruction
 LCC_RETURN wrapped_llvm_sys__instruction_getNextNonDebugInstruction_Instruction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Instruction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = llvmo ::llvm_sys__instruction_getNextNonDebugInstruction(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__instruction_eraseFromParent
 LCC_RETURN wrapped_llvm_sys__instruction_eraseFromParent_Instruction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Instruction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__instruction_eraseFromParent(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__getDebugLocInfo
 LCC_RETURN wrapped_llvm_sys__getDebugLocInfo_Instruction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Instruction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = llvmo ::llvm_sys__getDebugLocInfo(a0._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::GlobalVariable_O::make
 LCC_RETURN wrapped_GlobalVariable_O__make_Module_spType_spboolllvm__GlobalValue__LinkageTypescore__T_spcore__String_spcore__T_spllvm__GlobalValue__ThreadLocalMode (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::Type_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvm::GlobalValue::LinkageTypes> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::String_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::T_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<llvm::GlobalValue::ThreadLocalMode> a7 (core::T_sp((gc::Tagged)(in7)));
                     
    llvmo::GlobalVariable_sp ret = llvmo ::GlobalVariable_O::make(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v);
     return translate::to_object<llvmo::GlobalVariable_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::ConstantExpr_O::getIntToPtr
 LCC_RETURN wrapped_ConstantExpr_O__getIntToPtr_llvm__Constant_llvm__Type_bool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Constant*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Type*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::Constant_sp ret = llvmo ::ConstantExpr_O::getIntToPtr(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::Constant_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::ConstantExpr_O::getInBoundsGetElementPtr
 LCC_RETURN wrapped_ConstantExpr_O__getInBoundsGetElementPtr_llvm__Type_Constant_spcore__List_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::Constant_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::Constant_sp ret = llvmo ::ConstantExpr_O::getInBoundsGetElementPtr(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::Constant_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::BlockAddress_O::get
 LCC_RETURN wrapped_BlockAddress_O__get_Function_spBasicBlock_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::BasicBlock_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::BlockAddress_sp ret = llvmo ::BlockAddress_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::BlockAddress_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::ConstantArray_O::get
 LCC_RETURN wrapped_ConstantArray_O__get_ArrayType_spcore__List_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::ArrayType_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::Constant_sp ret = llvmo ::ConstantArray_O::get(a0._v,a1._v);
     return translate::to_object<llvmo::Constant_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::ConstantDataArray_O::getUInt32
 LCC_RETURN wrapped_ConstantDataArray_O__getUInt32_LLVMContext_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::LLVMContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::Constant_sp ret = llvmo ::ConstantDataArray_O::getUInt32(a0._v,a1._v);
     return translate::to_object<llvmo::Constant_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::EngineBuilder_O::make
 LCC_RETURN wrapped_EngineBuilder_O__make_Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::EngineBuilder_sp ret = llvmo ::EngineBuilder_O::make(a0._v);
     return translate::to_object<llvmo::EngineBuilder_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__setTargetTriple
 LCC_RETURN wrapped_llvm_sys__setTargetTriple_llvm__Module_llvm__StringRef (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Module*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::StringRef> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__setTargetTriple(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__module_get_function_list
 LCC_RETURN wrapped_llvm_sys__module_get_function_list_Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = llvmo ::llvm_sys__module_get_function_list(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::Module_O::make
 LCC_RETURN wrapped_Module_O__make_const_std__string_LLVMContext_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::LLVMContext_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::Module_sp ret = llvmo ::Module_O::make(a0._v,a1._v);
     return translate::to_object<llvmo::Module_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__valid
 LCC_RETURN wrapped_llvm_sys__valid_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = llvmo ::llvm_sys__valid(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__makeStringGlobal
 LCC_RETURN wrapped_llvm_sys__makeStringGlobal_Module_spcore__String_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::Value_sp ret = llvmo ::llvm_sys__makeStringGlobal(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::Value_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__valuep
 LCC_RETURN wrapped_llvm_sys__valuep_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = llvmo ::llvm_sys__valuep(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__clone_module
 LCC_RETURN wrapped_llvm_sys__clone_module_Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::Module_sp ret = llvmo ::llvm_sys__clone_module(a0._v);
     return translate::to_object<llvmo::Module_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__parseBitcodeFile
 LCC_RETURN wrapped_llvm_sys__parseBitcodeFile_core__T_spLLVMContext_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::LLVMContext_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::Module_sp ret = llvmo ::llvm_sys__parseBitcodeFile(a0._v,a1._v);
     return translate::to_object<llvmo::Module_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__parseIRString
 LCC_RETURN wrapped_llvm_sys__parseIRString_const_std__string_LLVMContext_spconst_std__string_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::LLVMContext_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const std::string&> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo::Module_sp ret = llvmo ::llvm_sys__parseIRString(a0._v,a1._v,a2._v);
     return translate::to_object<llvmo::Module_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__parseIRFile
 LCC_RETURN wrapped_llvm_sys__parseIRFile_core__T_spLLVMContext_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::LLVMContext_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo::Module_sp ret = llvmo ::llvm_sys__parseIRFile(a0._v,a1._v);
     return translate::to_object<llvmo::Module_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__writeBitcodeToFile
 LCC_RETURN wrapped_llvm_sys__writeBitcodeToFile_Module_spcore__String_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo ::llvm_sys__writeBitcodeToFile(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__writeIrToFile
 LCC_RETURN wrapped_llvm_sys__writeIrToFile_Module_spcore__String_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__writeIrToFile(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__printModuleToStream
 LCC_RETURN wrapped_llvm_sys__printModuleToStream_Module_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__printModuleToStream(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__printFunctionToStream
 LCC_RETURN wrapped_llvm_sys__printFunctionToStream_Function_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__printFunctionToStream(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__verifyFunction
 LCC_RETURN wrapped_llvm_sys__verifyFunction_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = llvmo ::llvm_sys__verifyFunction(a0._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::llvm_sys__verifyModule
 LCC_RETURN wrapped_llvm_sys__verifyModule_Module_spcore__Symbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::llvm_sys__verifyModule(a0._v,a1._v);
     return ret.as_return_type();
    }
// Do nothing yet for function get of type EXPOSE-EXTERN-DEFUN
// Do nothing yet for function getIfExists of type EXPOSE-EXTERN-DEFUN
// Do nothing yet for function get of type EXPOSE-EXTERN-DEFUN
// Generating code for llvmo::TargetOptions_O::make
 LCC_RETURN wrapped_TargetOptions_O__make_bool (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<bool> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::TargetOptions_sp ret = llvmo ::TargetOptions_O::make(a0._v);
     return translate::to_object<llvmo::TargetOptions_sp>::convert(ret).as_return_type();
    }
// Generating code for llvm::Intrinsic::lookupIntrinsicID
// return-type -> "llvm::Intrinsic::ID"
// arg-types -> ("llvm::StringRef")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_lookupIntrinsicID_llvm__StringRef (core::T_O* in0) {
    
    translate::from_object<llvm::StringRef> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::Intrinsic::ID ret = llvm::Intrinsic ::lookupIntrinsicID(a0._v);
     return translate::to_object<llvm::Intrinsic::ID>::convert(ret).as_return_type();
    }
// Generating code for llvm::Triple::normalize
// return-type -> "std::string"
// arg-types -> ("llvm::StringRef" "llvm::Triple::CanonicalForm")
//  Found at /usr/share/clasp/src/llvmo/llvmoExpose.cc-----------
 LCC_RETURN wrapped_normalize_llvm__StringRefllvm__Triple__CanonicalForm (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<llvm::StringRef> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::Triple::CanonicalForm> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    std::string ret = llvm::Triple ::normalize(a0._v,a1._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for llvmo::Triple_O::make
 LCC_RETURN wrapped_Triple_O__make_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::Triple_sp ret = llvmo ::Triple_O::make(a0._v);
     return translate::to_object<llvmo::Triple_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__sanity_check_module
 LCC_RETURN wrapped_llvm_sys__sanity_check_module_Module_spint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    llvmo ::llvm_sys__sanity_check_module(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__dump_instruction_list
 LCC_RETURN wrapped_llvm_sys__dump_instruction_list_BasicBlock_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::BasicBlock_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__dump_instruction_list(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__dump_instruction_pointers
 LCC_RETURN wrapped_llvm_sys__dump_instruction_pointers_llvm__Instruction_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Instruction*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__dump_instruction_pointers(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__create_invoke_instruction_append_to_basic_block
 LCC_RETURN wrapped_llvm_sys__create_invoke_instruction_append_to_basic_block_llvm__Function_llvm__BasicBlock_llvm__BasicBlock_core__List_spcore__String_spllvm__BasicBlock_ (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::Function*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvm::BasicBlock*> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<llvm::BasicBlock*> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::List_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::String_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<llvm::BasicBlock*> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    llvmo::Instruction_sp ret = llvmo ::llvm_sys__create_invoke_instruction_append_to_basic_block(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<llvmo::Instruction_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__linkModules
 LCC_RETURN wrapped_llvm_sys__linkModules_Module_spModule_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::Module_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::llvm_sys__linkModules(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::llvm_sys__link_in_module
 LCC_RETURN wrapped_llvm_sys__link_in_module_Linker_spModule_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Linker_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::Module_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::llvm_sys__link_in_module(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::Linker_O::make
 LCC_RETURN wrapped_Linker_O__make_Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::Linker_sp ret = llvmo ::Linker_O::make(a0._v);
     return translate::to_object<llvmo::Linker_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__call_with_thread_safe_context
 LCC_RETURN wrapped_llvm_sys__call_with_thread_safe_context_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = llvmo ::llvm_sys__call_with_thread_safe_context(a0._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::ThreadSafeContext_O::create_thread_safe_context
 LCC_RETURN wrapped_ThreadSafeContext_O__create_thread_safe_context_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo::ThreadSafeContext_sp ret = llvmo ::ThreadSafeContext_O::create_thread_safe_context();
     return translate::to_object<llvmo::ThreadSafeContext_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::LLVMContext_O::create_llvm_context
 LCC_RETURN wrapped_LLVMContext_O__create_llvm_context_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    llvmo::LLVMContext_sp ret = llvmo ::LLVMContext_O::create_llvm_context();
     return translate::to_object<llvmo::LLVMContext_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__disassemble_instructions
 LCC_RETURN wrapped_llvm_sys__disassemble_instructions_const_std__string_core__Pointer_spcore__Pointer_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Pointer_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    llvmo ::llvm_sys__disassemble_instructions(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__get_default_target_triple
 LCC_RETURN wrapped_llvm_sys__get_default_target_triple_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    std::string ret = llvmo ::llvm_sys__get_default_target_triple();
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__llvm_value_p
 LCC_RETURN wrapped_llvm_sys__llvm_value_p_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = llvmo ::llvm_sys__llvm_value_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__debugObjectFiles
 LCC_RETURN wrapped_llvm_sys__debugObjectFiles_core__Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__debugObjectFiles(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__dwTag
 LCC_RETURN wrapped_llvm_sys__dwTag_core__Symbol_spuint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<uint> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    uint ret = llvmo ::llvm_sys__dwTag(a0._v,a1._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for llvmo::DebugLoc_O::make
 LCC_RETURN wrapped_DebugLoc_O__make_const_llvm__DebugLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const llvm::DebugLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::DebugLoc_sp ret = llvmo ::DebugLoc_O::make(a0._v);
     return translate::to_object<llvmo::DebugLoc_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::llvm_sys__dwarf_context_verify
 LCC_RETURN wrapped_llvm_sys__dwarf_context_verify_DWARFContext_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::DWARFContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo ::llvm_sys__dwarf_context_verify(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for llvmo::llvm_sys__address_information
 LCC_RETURN wrapped_llvm_sys__address_information_void_bool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<void*> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = llvmo ::llvm_sys__address_information(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::DWARFContext_O::createDWARFContext
 LCC_RETURN wrapped_DWARFContext_O__createDWARFContext_ObjectFile_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::ObjectFile_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::DWARFContext_sp ret = llvmo ::DWARFContext_O::createDWARFContext(a0._v);
     return translate::to_object<llvmo::DWARFContext_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::getAddressRangesForAddress
 LCC_RETURN wrapped_getAddressRangesForAddress_DWARFContext_spSectionedAddress_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::DWARFContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::SectionedAddress_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = llvmo ::getAddressRangesForAddress(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::getLocalsForAddress
 LCC_RETURN wrapped_getLocalsForAddress_DWARFContext_spSectionedAddress_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::DWARFContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::SectionedAddress_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = llvmo ::getLocalsForAddress(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::getLineInfoForAddress_
 LCC_RETURN wrapped_getLineInfoForAddress__DWARFContext_spSectionedAddress_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::DWARFContext_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::SectionedAddress_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = llvmo ::getLineInfoForAddress_(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for llvmo::llvm_sys__createExpressionNone
 LCC_RETURN wrapped_llvm_sys__createExpressionNone_DIBuilder_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::DIBuilder_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvm::DIExpression* ret = llvmo ::llvm_sys__createExpressionNone(a0._v);
     return translate::to_object<llvm::DIExpression*>::convert(ret).as_return_type();
    }
// Generating code for llvmo::DIBuilder_O::make
 LCC_RETURN wrapped_DIBuilder_O__make_Module_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvmo::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    llvmo::DIBuilder_sp ret = llvmo ::DIBuilder_O::make(a0._v);
     return translate::to_object<llvmo::DIBuilder_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::DILocation_O::make
 LCC_RETURN wrapped_DILocation_O__make_llvm__LLVMContext_unsigned_intunsigned_intDINode_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<llvm::LLVMContext&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<unsigned int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<unsigned int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<llvmo::DINode_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    llvmo::DILocation_sp ret = llvmo ::DILocation_O::make(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<llvmo::DILocation_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__parse_dynamic_matcher
 LCC_RETURN wrapped_ast_tooling__parse_dynamic_matcher_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = asttooling ::ast_tooling__parse_dynamic_matcher(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__build_asts
 LCC_RETURN wrapped_ast_tooling__build_asts_clang__tooling__ClangTool_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::tooling::ClangTool&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = asttooling ::ast_tooling__build_asts(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__wrapped_JSONCompilationDatabase_loadFromFile
 LCC_RETURN wrapped_ast_tooling__wrapped_JSONCompilationDatabase_loadFromFile_core__T_spcore__Symbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = asttooling ::ast_tooling__wrapped_JSONCompilationDatabase_loadFromFile(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for asttooling::ast_tooling__getIncludeLoc
 LCC_RETURN wrapped_ast_tooling__getIncludeLoc_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clang::SourceLocation ret = asttooling ::ast_tooling__getIncludeLoc(a0._v);
     return translate::to_object<clang::SourceLocation>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__getColumn
 LCC_RETURN wrapped_ast_tooling__getColumn_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    unsigned ret = asttooling ::ast_tooling__getColumn(a0._v);
     return translate::to_object<unsigned>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__getLine
 LCC_RETURN wrapped_ast_tooling__getLine_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    unsigned ret = asttooling ::ast_tooling__getLine(a0._v);
     return translate::to_object<unsigned>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__PresumedLoc_getFilename
 LCC_RETURN wrapped_ast_tooling__PresumedLoc_getFilename_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    std::string ret = asttooling ::ast_tooling__PresumedLoc_getFilename(a0._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__isInvalid
 LCC_RETURN wrapped_ast_tooling__isInvalid_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = asttooling ::ast_tooling__isInvalid(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__isValid
 LCC_RETURN wrapped_ast_tooling__isValid_const_clang__PresumedLoc_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::PresumedLoc&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = asttooling ::ast_tooling__isValid(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__printToString
 LCC_RETURN wrapped_ast_tooling__printToString_const_clang__SourceLocation_const_clang__SourceManager_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::SourceLocation&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const clang::SourceManager&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    std::string ret = asttooling ::ast_tooling__printToString(a0._v,a1._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__isFileID
 LCC_RETURN wrapped_ast_tooling__isFileID_const_clang__SourceLocation_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const clang::SourceLocation&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = asttooling ::ast_tooling__isFileID(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__testDerivable
 LCC_RETURN wrapped_ast_tooling__testDerivable_clang__ast_matchers__MatchFinder__MatchCallback_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::ast_matchers::MatchFinder::MatchCallback*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    asttooling ::ast_tooling__testDerivable(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for asttooling::ast_tooling__clangVersionString
 LCC_RETURN wrapped_ast_tooling__clangVersionString_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = asttooling ::ast_tooling__clangVersionString();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__intern_matcher_keyword
 LCC_RETURN wrapped_ast_tooling__intern_matcher_keyword_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = asttooling ::ast_tooling__intern_matcher_keyword(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::ast_tooling__fix_matcher_name
 LCC_RETURN wrapped_ast_tooling__fix_matcher_name_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    std::string ret = asttooling ::ast_tooling__fix_matcher_name(a0._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__getTypePtrOrNull
 LCC_RETURN wrapped_cast__getTypePtrOrNull_clang__QualType (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::QualType> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = asttooling ::cast__getTypePtrOrNull(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__getCanonicalType
 LCC_RETURN wrapped_cast__getCanonicalType_clang__QualType (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::QualType> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clang::QualType ret = asttooling ::cast__getCanonicalType(a0._v);
     return translate::to_object<clang::QualType>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__isStaticLocal
 LCC_RETURN wrapped_cast__isStaticLocal_clang__VarDecl_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::VarDecl*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = asttooling ::cast__isStaticLocal(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__isCanonical
 LCC_RETURN wrapped_cast__isCanonical_clang__QualType (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::QualType> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = asttooling ::cast__isCanonical(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__getAsString
 LCC_RETURN wrapped_cast__getAsString_clang__QualType (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::QualType> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    std::string ret = asttooling ::cast__getAsString(a0._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__makeQualType
 LCC_RETURN wrapped_cast__makeQualType_clang__Type_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clang::Type*> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clang::QualType ret = asttooling ::cast__makeQualType(a0._v);
     return translate::to_object<clang::QualType>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__makeQualTypeDefault
 LCC_RETURN wrapped_cast__makeQualTypeDefault_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    clang::QualType ret = asttooling ::cast__makeQualTypeDefault();
     return translate::to_object<clang::QualType>::convert(ret).as_return_type();
    }
// Generating code for asttooling::cast__dump
 LCC_RETURN wrapped_cast__dump_core__T_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    asttooling ::cast__dump(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__num_logical_processors
 LCC_RETURN wrapped_core__num_logical_processors_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__num_logical_processors();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get_internal_run_time
 LCC_RETURN wrapped_cl__get_internal_run_time_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__get_internal_run_time();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__clock_gettime_nanoseconds
 LCC_RETURN wrapped_core__clock_gettime_nanoseconds_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Integer_sp ret = core ::core__clock_gettime_nanoseconds();
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get_internal_real_time
 LCC_RETURN wrapped_cl__get_internal_real_time_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__get_internal_real_time();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__ensure_directories_exist
 LCC_RETURN wrapped_cl__ensure_directories_exist_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__ensure_directories_exist(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__elt
 LCC_RETURN wrapped_cl__elt_T_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__elt(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__copy_seq
 LCC_RETURN wrapped_cl__copy_seq_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__copy_seq(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__subseq
 LCC_RETURN wrapped_cl__subseq_T_spsize_tT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__subseq(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nreverse
 LCC_RETURN wrapped_cl__nreverse_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__nreverse(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__reverse
 LCC_RETURN wrapped_cl__reverse_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__reverse(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__length
 LCC_RETURN wrapped_cl__length_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::cl__length(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::coerce_to_package
 LCC_RETURN wrapped_coerce_to_package_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Package_sp ret = core ::coerce_to_package(a0._v);
     return translate::to_object<core::Package_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_called_fdesignator
 LCC_RETURN wrapped_core__coerce_called_fdesignator_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Function_sp ret = core ::core__coerce_called_fdesignator(a0._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::coerce_fdesignator
 LCC_RETURN wrapped_coerce_fdesignator_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Function_sp ret = core ::coerce_fdesignator(a0._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__code_char
 LCC_RETURN wrapped_cl__code_char_Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Character_sp ret = core ::cl__code_char(a0._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_int
 LCC_RETURN wrapped_cl__char_int_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = core ::cl__char_int(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_code
 LCC_RETURN wrapped_cl__char_code_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = core ::cl__char_code(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__all_characters
 LCC_RETURN wrapped_core__all_characters_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__all_characters();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_name
 LCC_RETURN wrapped_cl__char_name_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleBaseString_sp ret = core ::cl__char_name(a0._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__name_char
 LCC_RETURN wrapped_cl__name_char_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__name_char(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__digit_char_p
 LCC_RETURN wrapped_cl__digit_char_p_Character_spFixnum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__digit_char_p(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__alpha_char_p
 LCC_RETURN wrapped_cl__alpha_char_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__alpha_char_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__standard_char_p
 LCC_RETURN wrapped_cl__standard_char_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__standard_char_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_equal
 LCC_RETURN wrapped_cl__char_equal_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__char_equal(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_equal
 LCC_RETURN wrapped_core__two_arg_char_equal_Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_equal(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_not_equal
 LCC_RETURN wrapped_cl__char_not_equal_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__char_not_equal(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__char_EQ_
 LCC_RETURN wrapped_cl__char_EQ__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__char_EQ_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_NE_
 LCC_RETURN wrapped_cl__char_NE__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__char_NE_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_not_lessp
 LCC_RETURN wrapped_cl__char_not_lessp_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_not_lessp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_not_lessp
 LCC_RETURN wrapped_core__two_arg_char_not_lessp_Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_not_lessp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_not_greaterp
 LCC_RETURN wrapped_cl__char_not_greaterp_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_not_greaterp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_not_greaterp
 LCC_RETURN wrapped_core__two_arg_char_not_greaterp_Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_not_greaterp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_greaterp
 LCC_RETURN wrapped_cl__char_greaterp_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_greaterp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_greaterp
 LCC_RETURN wrapped_core__two_arg_char_greaterp_Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_greaterp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_lessp
 LCC_RETURN wrapped_cl__char_lessp_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_lessp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_lessp
 LCC_RETURN wrapped_core__two_arg_char_lessp_Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_lessp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_GE_
 LCC_RETURN wrapped_cl__char_GE__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_GE_(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_GE_
 LCC_RETURN wrapped_core__two_arg_char_GE__Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_GE_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_LE_
 LCC_RETURN wrapped_cl__char_LE__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_LE_(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_LE_
 LCC_RETURN wrapped_core__two_arg_char_LE__Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_LE_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_GT_
 LCC_RETURN wrapped_cl__char_GT__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_GT_(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_GT_
 LCC_RETURN wrapped_core__two_arg_char_GT__Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_GT_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_LT_
 LCC_RETURN wrapped_cl__char_LT__Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__char_LT_(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__two_arg_char_LT_
 LCC_RETURN wrapped_core__two_arg_char_LT__Character_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__two_arg_char_LT_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_downcase
 LCC_RETURN wrapped_cl__char_downcase_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Character_sp ret = core ::cl__char_downcase(a0._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__char_upcase
 LCC_RETURN wrapped_cl__char_upcase_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Character_sp ret = core ::cl__char_upcase(a0._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__alphanumericp
 LCC_RETURN wrapped_cl__alphanumericp_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__alphanumericp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__both_case_p
 LCC_RETURN wrapped_cl__both_case_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__both_case_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__upper_case_p
 LCC_RETURN wrapped_cl__upper_case_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__upper_case_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lower_case_p
 LCC_RETURN wrapped_cl__lower_case_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__lower_case_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__graphic_char_p
 LCC_RETURN wrapped_cl__graphic_char_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__graphic_char_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__printing_char_p
 LCC_RETURN wrapped_core__printing_char_p_Character_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__printing_char_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__derivable_stamp
 LCC_RETURN wrapped_core__derivable_stamp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__derivable_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__ensure_single_dispatch_method
 LCC_RETURN wrapped_core__ensure_single_dispatch_method_SingleDispatchGenericFunction_spT_spInstance_spList_spT_spFunction_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SingleDispatchGenericFunction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Instance_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::List_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::Function_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core ::core__ensure_single_dispatch_method(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__ensure_single_dispatch_generic_function
 LCC_RETURN wrapped_core__ensure_single_dispatch_generic_function_T_spboolsize_tList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::List_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SingleDispatchGenericFunction_sp ret = core ::core__ensure_single_dispatch_generic_function(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SingleDispatchGenericFunction_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sdgf_methods
 LCC_RETURN wrapped_core__sdgf_methods_SingleDispatchGenericFunction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SingleDispatchGenericFunction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__sdgf_methods(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__specializerIndices
 LCC_RETURN wrapped_core__specializerIndices_SingleDispatchGenericFunction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SingleDispatchGenericFunction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__specializerIndices(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__callHistory
 LCC_RETURN wrapped_core__callHistory_SingleDispatchGenericFunction_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SingleDispatchGenericFunction_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__callHistory(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_documentation
 LCC_RETURN wrapped_core__set_documentation_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__set_documentation(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__remove_annotation
 LCC_RETURN wrapped_ext__remove_annotation_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::ext__remove_annotation(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::ext__annotate
 LCC_RETURN wrapped_ext__annotate_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = core ::ext__annotate(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for core::core__rem_record_field
 LCC_RETURN wrapped_core__rem_record_field_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__rem_record_field(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_record_field
 LCC_RETURN wrapped_core__set_record_field_List_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__set_record_field(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__record_field
 LCC_RETURN wrapped_core__record_field_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__record_field(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__record_cons
 LCC_RETURN wrapped_core__record_cons_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__record_cons(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_process
 LCC_RETURN wrapped_core__backquote_process_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_process(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_bracket
 LCC_RETURN wrapped_core__backquote_bracket_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_bracket(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_completely_process
 LCC_RETURN wrapped_core__backquote_completely_process_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__backquote_completely_process(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__backquote_simplify
 LCC_RETURN wrapped_core__backquote_simplify_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_simplify(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_simplify_args
 LCC_RETURN wrapped_core__backquote_simplify_args_Cons_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Cons_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_simplify_args(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_attach_append
 LCC_RETURN wrapped_core__backquote_attach_append_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__backquote_attach_append(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_frob
 LCC_RETURN wrapped_core__backquote_frob_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__backquote_frob(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_splicing_frob
 LCC_RETURN wrapped_core__backquote_splicing_frob_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__backquote_splicing_frob(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_attach_conses
 LCC_RETURN wrapped_core__backquote_attach_conses_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__backquote_attach_conses(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_null_or_quoted
 LCC_RETURN wrapped_core__backquote_null_or_quoted_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_null_or_quoted(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_remove_tokens
 LCC_RETURN wrapped_core__backquote_remove_tokens_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_remove_tokens(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_maptree
 LCC_RETURN wrapped_core__backquote_maptree_Function_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__backquote_maptree(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_append_list
 LCC_RETURN wrapped_core__backquote_append_list_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_append_list(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__backquote_append
 LCC_RETURN wrapped_core__backquote_append_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__backquote_append(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__clformat
 LCC_RETURN wrapped_core__clformat_T_spT_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__clformat(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__format
 LCC_RETURN wrapped_cl__format_T_spT_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__format(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fflush
 LCC_RETURN wrapped_core__fflush_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__fflush();
     return Values0<core::T_O>();
    }
// Generating code for core::core__fmt
 LCC_RETURN wrapped_core__fmt_T_spconst_string_List_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__fmt(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__tostring
 LCC_RETURN wrapped_core__tostring_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    std::string ret = core ::core__tostring(a0._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for core::core__tokenize_format_specifiers
 LCC_RETURN wrapped_core__tokenize_format_specifiers_const_string_bool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__tokenize_format_specifiers(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rem_sysprop
 LCC_RETURN wrapped_core__rem_sysprop_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__rem_sysprop(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__get_sysprop
 LCC_RETURN wrapped_core__get_sysprop_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__get_sysprop(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__iterator_step
 LCC_RETURN wrapped_core__iterator_step_Iterator_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Iterator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Iterator_sp ret = core ::core__iterator_step(a0._v);
     return translate::to_object<core::Iterator_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__iterator_unsafe_element
 LCC_RETURN wrapped_core__iterator_unsafe_element_Iterator_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Iterator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__iterator_unsafe_element(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__replace_foreign_memory
 LCC_RETURN wrapped_core__replace_foreign_memory_clasp_ffi__ForeignData_spclasp_ffi__ForeignData_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<clasp_ffi::ForeignData_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__replace_foreign_memory(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__fill_foreign_memory
 LCC_RETURN wrapped_core__fill_foreign_memory_clasp_ffi__ForeignData_spsize_tsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__fill_foreign_memory(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__pointer_in_pointer_range
 LCC_RETURN wrapped_core__pointer_in_pointer_range_Pointer_spPointer_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    bool ret = core ::core__pointer_in_pointer_range(a0._v,a1._v,a2._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__pointer_as_string
 LCC_RETURN wrapped_core__pointer_as_string_Pointer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleBaseString_sp ret = core ::core__pointer_as_string(a0._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_pointer
 LCC_RETURN wrapped_core__make_pointer_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pointer_sp ret = core ::core__make_pointer(a0._v);
     return translate::to_object<core::Pointer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__equalp
 LCC_RETURN wrapped_cl__equalp_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__equalp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__sl_boundp
 LCC_RETURN wrapped_core__sl_boundp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__sl_boundp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_ref
 LCC_RETURN wrapped_core__instance_ref_T_spint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__instance_ref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_sig_set
 LCC_RETURN wrapped_core__instance_sig_set_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__instance_sig_set(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_sig
 LCC_RETURN wrapped_core__instance_sig_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__instance_sig(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__class_name_as_string
 LCC_RETURN wrapped_core__class_name_as_string_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    string ret = core ::core__class_name_as_string(a0._v);
     return translate::to_object<string>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_class
 LCC_RETURN wrapped_core__instance_class_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Instance_sp ret = core ::core__instance_class(a0._v);
     return translate::to_object<core::Instance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__implementation_class
 LCC_RETURN wrapped_core__implementation_class_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__implementation_class(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__copy_tree
 LCC_RETURN wrapped_cl__copy_tree_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__copy_tree(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__print_cxx_object
 LCC_RETURN wrapped_core__print_cxx_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__print_cxx_object(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__decode
 LCC_RETURN wrapped_core__decode_T_spcore__List_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__decode(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__encode
 LCC_RETURN wrapped_core__encode_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__encode(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fieldsp
 LCC_RETURN wrapped_core__fieldsp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__fieldsp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__load_cxx_object
 LCC_RETURN wrapped_core__load_cxx_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__load_cxx_object(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_cxx_object
 LCC_RETURN wrapped_core__make_cxx_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__make_cxx_object(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_symbol_layout
 LCC_RETURN wrapped_core__verify_symbol_layout_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__verify_symbol_layout(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__no_thread_local_bindingp
 LCC_RETURN wrapped_core__no_thread_local_bindingp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__no_thread_local_bindingp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__fullName
 LCC_RETURN wrapped_core__fullName_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    string ret = core ::core__fullName(a0._v);
     return translate::to_object<string>::convert(ret).as_return_type();
    }
// Generating code for core::core__STARmakeSpecial
 LCC_RETURN wrapped_core__STARmakeSpecial_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__STARmakeSpecial(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__asKeywordSymbol
 LCC_RETURN wrapped_core__asKeywordSymbol_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::core__asKeywordSymbol(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__copy_symbol
 LCC_RETURN wrapped_cl__copy_symbol_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Symbol_sp ret = core ::cl__copy_symbol(a0._v,a1._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__makunbound
 LCC_RETURN wrapped_cl__makunbound_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::cl__makunbound(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__variable_cell_name
 LCC_RETURN wrapped_core__variable_cell_name_VariableCell_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::VariableCell_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__variable_cell_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__variable_cell
 LCC_RETURN wrapped_core__variable_cell_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__variable_cell(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__ensure_variable_cell
 LCC_RETURN wrapped_core__ensure_variable_cell_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::VariableCell_sp ret = core ::core__ensure_variable_cell(a0._v);
     return translate::to_object<core::VariableCell_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_symbol
 LCC_RETURN wrapped_cl__make_symbol_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::cl__make_symbol(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cas_symbol_value
 LCC_RETURN wrapped_core__cas_symbol_value_T_spT_spSymbol_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__cas_symbol_value(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__atomic_set_symbol_value
 LCC_RETURN wrapped_core__atomic_set_symbol_value_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__atomic_set_symbol_value(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__atomic_symbol_value
 LCC_RETURN wrapped_core__atomic_symbol_value_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__atomic_symbol_value(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__symbol_global_value_set
 LCC_RETURN wrapped_core__symbol_global_value_set_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__symbol_global_value_set(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__symbol_global_value
 LCC_RETURN wrapped_core__symbol_global_value_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__symbol_global_value(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbol_value
 LCC_RETURN wrapped_cl__symbol_value_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__symbol_value(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbol_name
 LCC_RETURN wrapped_cl__symbol_name_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleString_sp ret = core ::cl__symbol_name(a0._v);
     return translate::to_object<core::SimpleString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__specialp
 LCC_RETURN wrapped_ext__specialp_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__specialp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbol_function
 LCC_RETURN wrapped_cl__symbol_function_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Function_sp ret = core ::cl__symbol_function(a0._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbol_package
 LCC_RETURN wrapped_cl__symbol_package_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__symbol_package(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__boundp
 LCC_RETURN wrapped_cl__boundp_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__boundp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get
 LCC_RETURN wrapped_cl__get_Symbol_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__get(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cas_symbol_plist
 LCC_RETURN wrapped_core__cas_symbol_plist_List_spList_spSymbol_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::List_sp ret = core ::core__cas_symbol_plist(a0._v,a1._v,a2._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__atomic_set_symbol_plist
 LCC_RETURN wrapped_core__atomic_set_symbol_plist_List_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__atomic_set_symbol_plist(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__atomic_symbol_plist
 LCC_RETURN wrapped_core__atomic_symbol_plist_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__atomic_symbol_plist(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbol_plist
 LCC_RETURN wrapped_cl__symbol_plist_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::cl__symbol_plist(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_cons_layout
 LCC_RETURN wrapped_core__verify_cons_layout_size_tsize_tsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__verify_cons_layout(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__alist_assoc_equal
 LCC_RETURN wrapped_core__alist_assoc_equal_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__alist_assoc_equal(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__alist_assoc_eql
 LCC_RETURN wrapped_core__alist_assoc_eql_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__alist_assoc_eql(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__alist_assoc_eq
 LCC_RETURN wrapped_core__alist_assoc_eq_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__alist_assoc_eq(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cons_length
 LCC_RETURN wrapped_core__cons_length_Cons_sp (core::T_O* in0) {
    
    translate::from_object<core::Cons_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__cons_length(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__list_nreverse
 LCC_RETURN wrapped_core__list_nreverse_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__list_nreverse(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__list_reverse
 LCC_RETURN wrapped_core__list_reverse_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__list_reverse(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__append2
 LCC_RETURN wrapped_core__append2_List_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__append2(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_list
 LCC_RETURN wrapped_cl__make_list_FixnumT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::cl__make_list(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cas_cdr
 LCC_RETURN wrapped_core__cas_cdr_T_spT_spT_spCons_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Cons_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__cas_cdr(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cas_car
 LCC_RETURN wrapped_core__cas_car_T_spT_spT_spCons_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Cons_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__cas_car(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rplacd_atomic
 LCC_RETURN wrapped_core__rplacd_atomic_T_spT_spCons_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Cons_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Cons_sp ret = core ::core__rplacd_atomic(a0._v,a1._v,a2._v);
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rplaca_atomic
 LCC_RETURN wrapped_core__rplaca_atomic_T_spT_spCons_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Cons_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Cons_sp ret = core ::core__rplaca_atomic(a0._v,a1._v,a2._v);
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rplacd
 LCC_RETURN wrapped_cl__rplacd_Cons_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Cons_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Cons_sp ret = core ::cl__rplacd(a0._v,a1._v);
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rplaca
 LCC_RETURN wrapped_cl__rplaca_Cons_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Cons_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Cons_sp ret = core ::cl__rplaca(a0._v,a1._v);
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cdr_atomic
 LCC_RETURN wrapped_core__cdr_atomic_T_spCons_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Cons_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__cdr_atomic(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__car_atomic
 LCC_RETURN wrapped_core__car_atomic_T_spCons_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Cons_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__car_atomic(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__cons
 LCC_RETURN wrapped_cl__cons_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Cons_sp ret = core ::cl__cons(a0._v,a1._v);
     return translate::to_object<core::Cons_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rem_f
 LCC_RETURN wrapped_core__rem_f_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__rem_f(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__getf
 LCC_RETURN wrapped_cl__getf_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__getf(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__put_f
 LCC_RETURN wrapped_core__put_f_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::List_sp ret = core ::core__put_f(a0._v,a1._v,a2._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_eclector_reader_readmacros
 LCC_RETURN wrapped_core__set_eclector_reader_readmacros_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_eclector_reader_readmacros(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__sbv_position_one
 LCC_RETURN wrapped_core__sbv_position_one_SimpleBitVector_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__sbv_position_one(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_zerop
 LCC_RETURN wrapped_core__sbv_zerop_SimpleBitVector_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__sbv_zerop(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_popcnt
 LCC_RETURN wrapped_core__sbv_popcnt_SimpleBitVector_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::core__sbv_popcnt(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_not
 LCC_RETURN wrapped_core__sbv_bit_not_SimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_not(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_orc2
 LCC_RETURN wrapped_core__sbv_bit_orc2_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_orc2(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_orc1
 LCC_RETURN wrapped_core__sbv_bit_orc1_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_orc1(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_andc2
 LCC_RETURN wrapped_core__sbv_bit_andc2_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_andc2(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_andc1
 LCC_RETURN wrapped_core__sbv_bit_andc1_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_andc1(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_eqv
 LCC_RETURN wrapped_core__sbv_bit_eqv_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_eqv(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_nor
 LCC_RETURN wrapped_core__sbv_bit_nor_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_nor(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_nand
 LCC_RETURN wrapped_core__sbv_bit_nand_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_nand(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_xor
 LCC_RETURN wrapped_core__sbv_bit_xor_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_xor(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_ior
 LCC_RETURN wrapped_core__sbv_bit_ior_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_ior(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sbv_bit_and
 LCC_RETURN wrapped_core__sbv_bit_and_SimpleBitVector_spSimpleBitVector_spSimpleBitVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBitVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBitVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::SimpleBitVector_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SimpleBitVector_sp ret = core ::core__sbv_bit_and(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fits_in_base_string
 LCC_RETURN wrapped_core__fits_in_base_string_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__fits_in_base_string(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__copy_to_simple_base_string
 LCC_RETURN wrapped_core__copy_to_simple_base_string_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__copy_to_simple_base_string(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__split
 LCC_RETURN wrapped_core__split_const_string_const_string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__split(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__search_string
 LCC_RETURN wrapped_core__search_string_String_spsize_tsize_tString_spsize_tsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::String_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<size_t> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<size_t> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::core__search_string(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__base_string_concatenate
 LCC_RETURN wrapped_core__base_string_concatenate_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__base_string_concatenate(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__parse_integer
 LCC_RETURN wrapped_cl__parse_integer_String_spFixnumT_spuintT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<uint> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    auto ret = core ::cl__parse_integer(a0._v,a1._v,a2._v,a3._v,a4._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__char
 LCC_RETURN wrapped_cl__char_String_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Character_sp ret = core ::cl__char(a0._v,a1._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__schar
 LCC_RETURN wrapped_cl__schar_AbstractSimpleVector_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::AbstractSimpleVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Character_sp ret = core ::cl__schar(a0._v,a1._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_string
 LCC_RETURN wrapped_cl__make_string_Fixnum_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__make_string(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_not_lessp
 LCC_RETURN wrapped_cl__string_not_lessp_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_not_lessp(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_not_greaterp
 LCC_RETURN wrapped_cl__string_not_greaterp_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_not_greaterp(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_greaterp
 LCC_RETURN wrapped_cl__string_greaterp_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_greaterp(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_lessp
 LCC_RETURN wrapped_cl__string_lessp_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_lessp(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_not_equal
 LCC_RETURN wrapped_cl__string_not_equal_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_not_equal(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_equal
 LCC_RETURN wrapped_cl__string_equal_T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_equal(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_GE_
 LCC_RETURN wrapped_cl__string_GE__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_GE_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_LE_
 LCC_RETURN wrapped_cl__string_LE__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_LE_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_GT_
 LCC_RETURN wrapped_cl__string_GT__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_GT_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_LT_
 LCC_RETURN wrapped_cl__string_LT__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_LT_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_NE_
 LCC_RETURN wrapped_cl__string_NE__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_NE_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_EQ_
 LCC_RETURN wrapped_cl__string_EQ__T_spT_spFixnum_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__string_EQ_(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nstring_downcase
 LCC_RETURN wrapped_cl__nstring_downcase_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::cl__nstring_downcase(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nstring_upcase
 LCC_RETURN wrapped_cl__nstring_upcase_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::cl__nstring_upcase(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_downcase
 LCC_RETURN wrapped_cl__string_downcase_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleString_sp ret = core ::cl__string_downcase(a0._v);
     return translate::to_object<core::SimpleString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_upcase
 LCC_RETURN wrapped_cl__string_upcase_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleString_sp ret = core ::cl__string_upcase(a0._v);
     return translate::to_object<core::SimpleString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string
 LCC_RETURN wrapped_cl__string_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::cl__string(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_right_trim
 LCC_RETURN wrapped_cl__string_right_trim_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::String_sp ret = core ::cl__string_right_trim(a0._v,a1._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_left_trim
 LCC_RETURN wrapped_cl__string_left_trim_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::String_sp ret = core ::cl__string_left_trim(a0._v,a1._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__string_trim
 LCC_RETURN wrapped_cl__string_trim_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::String_sp ret = core ::cl__string_trim(a0._v,a1._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__array_no_nans_p
 LCC_RETURN wrapped_ext__array_no_nans_p_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__array_no_nans_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::ext__pinned_objects_funcall
 LCC_RETURN wrapped_ext__pinned_objects_funcall_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::ext__pinned_objects_funcall(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__array_pointer
 LCC_RETURN wrapped_ext__array_pointer_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = core ::ext__array_pointer(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__array_storage_vector
 LCC_RETURN wrapped_ext__array_storage_vector_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Array_sp ret = core ::ext__array_storage_vector(a0._v);
     return translate::to_object<core::Array_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__static_vector_pointer
 LCC_RETURN wrapped_core__static_vector_pointer_Array_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    clasp_ffi::ForeignData_sp ret = core ::core__static_vector_pointer(a0._v,a1._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__static_vector_address
 LCC_RETURN wrapped_core__static_vector_address_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = core ::core__static_vector_address(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_memory_to_foreign_data
 LCC_RETURN wrapped_core__coerce_memory_to_foreign_data_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = core ::core__coerce_memory_to_foreign_data(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_to_byte8_vector
 LCC_RETURN wrapped_core__coerce_to_byte8_vector_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Array_sp ret = core ::core__coerce_to_byte8_vector(a0._v);
     return translate::to_object<core::Array_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_mdarray_layout
 LCC_RETURN wrapped_core__verify_mdarray_layout_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__verify_mdarray_layout(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__verify_simple_vector_layout
 LCC_RETURN wrapped_core__verify_simple_vector_layout_size_tsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__verify_simple_vector_layout(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__vector_push_extend
 LCC_RETURN wrapped_cl__vector_push_extend_T_spVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Fixnum_sp ret = core ::cl__vector_push_extend(a0._v,a1._v,a2._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__vector_push
 LCC_RETURN wrapped_cl__vector_push_T_spVector_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__vector_push(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_mdarray
 LCC_RETURN wrapped_core__make_mdarray_List_spT_spboolT_spFixnum_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<bool> a6 (core::T_sp((gc::Tagged)(in6)));
                     
    core::MDArray_sp ret = core ::core__make_mdarray(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v);
     return translate::to_object<core::MDArray_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_static_vector
 LCC_RETURN wrapped_core__make_static_vector_T_spsize_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::Vector_sp ret = core ::core__make_static_vector(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::Vector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_vector
 LCC_RETURN wrapped_core__make_vector_T_spsize_tboolT_spT_spFixnum_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::Fixnum_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::T_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<bool> a7 (core::T_sp((gc::Tagged)(in7)));
                     
    core::Vector_sp ret = core ::core__make_vector(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v);
     return translate::to_object<core::Vector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_size_t
 LCC_RETURN wrapped_core__make_simple_mdarray_size_t_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_size_t_sp ret = core ::core__make_simple_mdarray_size_t(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_size_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_fixnum
 LCC_RETURN wrapped_core__make_simple_mdarray_fixnum_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_fixnum_sp ret = core ::core__make_simple_mdarray_fixnum(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte64
 LCC_RETURN wrapped_core__make_simple_mdarray_byte64_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte64_t_sp ret = core ::core__make_simple_mdarray_byte64(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte64_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int64
 LCC_RETURN wrapped_core__make_simple_mdarray_int64_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int64_t_sp ret = core ::core__make_simple_mdarray_int64(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int64_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte32
 LCC_RETURN wrapped_core__make_simple_mdarray_byte32_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte32_t_sp ret = core ::core__make_simple_mdarray_byte32(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte32_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int32
 LCC_RETURN wrapped_core__make_simple_mdarray_int32_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int32_t_sp ret = core ::core__make_simple_mdarray_int32(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int32_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte16
 LCC_RETURN wrapped_core__make_simple_mdarray_byte16_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte16_t_sp ret = core ::core__make_simple_mdarray_byte16(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte16_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int16
 LCC_RETURN wrapped_core__make_simple_mdarray_int16_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int16_t_sp ret = core ::core__make_simple_mdarray_int16(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int16_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte8
 LCC_RETURN wrapped_core__make_simple_mdarray_byte8_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte8_t_sp ret = core ::core__make_simple_mdarray_byte8(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int8
 LCC_RETURN wrapped_core__make_simple_mdarray_int8_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int8_t_sp ret = core ::core__make_simple_mdarray_int8(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte4
 LCC_RETURN wrapped_core__make_simple_mdarray_byte4_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte4_t_sp ret = core ::core__make_simple_mdarray_byte4(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte4_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int4
 LCC_RETURN wrapped_core__make_simple_mdarray_int4_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int4_t_sp ret = core ::core__make_simple_mdarray_int4(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int4_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_byte2
 LCC_RETURN wrapped_core__make_simple_mdarray_byte2_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_byte2_t_sp ret = core ::core__make_simple_mdarray_byte2(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_byte2_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_int2
 LCC_RETURN wrapped_core__make_simple_mdarray_int2_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_int2_t_sp ret = core ::core__make_simple_mdarray_int2(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_int2_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_long_float
 LCC_RETURN wrapped_core__make_simple_mdarray_long_float_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_long_float_sp ret = core ::core__make_simple_mdarray_long_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_long_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_double_float
 LCC_RETURN wrapped_core__make_simple_mdarray_double_float_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_double_sp ret = core ::core__make_simple_mdarray_double_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_double_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_single_float
 LCC_RETURN wrapped_core__make_simple_mdarray_single_float_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_float_sp ret = core ::core__make_simple_mdarray_single_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_short_float
 LCC_RETURN wrapped_core__make_simple_mdarray_short_float_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArray_float_sp ret = core ::core__make_simple_mdarray_short_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArray_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_character
 LCC_RETURN wrapped_core__make_simple_mdarray_character_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArrayCharacter_sp ret = core ::core__make_simple_mdarray_character(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArrayCharacter_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_base_char
 LCC_RETURN wrapped_core__make_simple_mdarray_base_char_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArrayBaseChar_sp ret = core ::core__make_simple_mdarray_base_char(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArrayBaseChar_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_bit
 LCC_RETURN wrapped_core__make_simple_mdarray_bit_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArrayBit_sp ret = core ::core__make_simple_mdarray_bit(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArrayBit_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_mdarray_t
 LCC_RETURN wrapped_core__make_simple_mdarray_t_List_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleMDArrayT_sp ret = core ::core__make_simple_mdarray_t(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleMDArrayT_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_size_t
 LCC_RETURN wrapped_core__make_simple_vector_size_t_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_size_t_sp ret = core ::core__make_simple_vector_size_t(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_size_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_fixnum
 LCC_RETURN wrapped_core__make_simple_vector_fixnum_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_fixnum_sp ret = core ::core__make_simple_vector_fixnum(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte64
 LCC_RETURN wrapped_core__make_simple_vector_byte64_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte64_t_sp ret = core ::core__make_simple_vector_byte64(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte64_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int64
 LCC_RETURN wrapped_core__make_simple_vector_int64_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int64_t_sp ret = core ::core__make_simple_vector_int64(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int64_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte32
 LCC_RETURN wrapped_core__make_simple_vector_byte32_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte32_t_sp ret = core ::core__make_simple_vector_byte32(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte32_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int32
 LCC_RETURN wrapped_core__make_simple_vector_int32_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int32_t_sp ret = core ::core__make_simple_vector_int32(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int32_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte16
 LCC_RETURN wrapped_core__make_simple_vector_byte16_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte16_t_sp ret = core ::core__make_simple_vector_byte16(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte16_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int16
 LCC_RETURN wrapped_core__make_simple_vector_int16_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int16_t_sp ret = core ::core__make_simple_vector_int16(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int16_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte8
 LCC_RETURN wrapped_core__make_simple_vector_byte8_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte8_t_sp ret = core ::core__make_simple_vector_byte8(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int8
 LCC_RETURN wrapped_core__make_simple_vector_int8_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int8_t_sp ret = core ::core__make_simple_vector_int8(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte4
 LCC_RETURN wrapped_core__make_simple_vector_byte4_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte4_t_sp ret = core ::core__make_simple_vector_byte4(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte4_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int4
 LCC_RETURN wrapped_core__make_simple_vector_int4_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int4_t_sp ret = core ::core__make_simple_vector_int4(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int4_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_byte2
 LCC_RETURN wrapped_core__make_simple_vector_byte2_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_byte2_t_sp ret = core ::core__make_simple_vector_byte2(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_byte2_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_int2
 LCC_RETURN wrapped_core__make_simple_vector_int2_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_int2_t_sp ret = core ::core__make_simple_vector_int2(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_int2_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_long_float
 LCC_RETURN wrapped_core__make_simple_vector_long_float_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_long_float_sp ret = core ::core__make_simple_vector_long_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_long_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_short_float
 LCC_RETURN wrapped_core__make_simple_vector_short_float_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_float_sp ret = core ::core__make_simple_vector_short_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_double_float
 LCC_RETURN wrapped_core__make_simple_vector_double_float_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_double_sp ret = core ::core__make_simple_vector_double_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_double_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_single_float
 LCC_RETURN wrapped_core__make_simple_vector_single_float_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_float_sp ret = core ::core__make_simple_vector_single_float(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_character
 LCC_RETURN wrapped_core__make_simple_vector_character_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleCharacterString_sp ret = core ::core__make_simple_vector_character(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleCharacterString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_base_char
 LCC_RETURN wrapped_core__make_simple_vector_base_char_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleBaseString_sp ret = core ::core__make_simple_vector_base_char(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_bit
 LCC_RETURN wrapped_core__make_simple_vector_bit_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleBitVector_sp ret = core ::core__make_simple_vector_bit(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleBitVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_vector_t
 LCC_RETURN wrapped_core__make_simple_vector_t_size_tT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleVector_sp ret = core ::core__make_simple_vector_t(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleVector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__vector
 LCC_RETURN wrapped_cl__vector_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Vector_sp ret = core ::cl__vector(a0._v);
     return translate::to_object<core::Vector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__replace_array
 LCC_RETURN wrapped_core__replace_array_Array_spArray_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Array_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__replace_array(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fillArrayWithElt
 LCC_RETURN wrapped_core__fillArrayWithElt_Array_spT_spcl_indexT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<cl_index> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core ::core__fillArrayWithElt(a0._v,a1._v,a2._v,a3._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__svref
 LCC_RETURN wrapped_cl__svref_SimpleVector_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__svref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__index
 LCC_RETURN wrapped_core__index_Array_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    gc::Fixnum ret = core ::core__index(a0._v,a1._v);
     return translate::to_object<gc::Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__acas
 LCC_RETURN wrapped_core__acas_T_spT_spT_spArray_spVaslist_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Array_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Vaslist_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::core__acas(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__atomic_aref
 LCC_RETURN wrapped_core__atomic_aref_T_spArray_spVaslist_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Array_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Vaslist_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__atomic_aref(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__aref
 LCC_RETURN wrapped_cl__aref_Array_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__aref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__copy_subarray
 LCC_RETURN wrapped_core__copy_subarray_Array_spFixnum_spArray_spFixnum_spFixnum_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Array_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Fixnum_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Fixnum_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core ::core__copy_subarray(a0._v,a1._v,a2._v,a3._v,a4._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__PERCENTdisplaced_index_offset
 LCC_RETURN wrapped_core__PERCENTdisplaced_index_offset_MDArray_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::MDArray_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__PERCENTdisplaced_index_offset(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__PERCENTdisplacement
 LCC_RETURN wrapped_core__PERCENTdisplacement_MDArray_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::MDArray_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__PERCENTdisplacement(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__array_displacement
 LCC_RETURN wrapped_cl__array_displacement_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__array_displacement(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__array_rank
 LCC_RETURN wrapped_cl__array_rank_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::cl__array_rank(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayTotalSize
 LCC_RETURN wrapped_cl__arrayTotalSize_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::cl__arrayTotalSize(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayHasFillPointerP
 LCC_RETURN wrapped_cl__arrayHasFillPointerP_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__arrayHasFillPointerP(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__fillPointer
 LCC_RETURN wrapped_cl__fillPointer_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::cl__fillPointer(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__mdarray_dump
 LCC_RETURN wrapped_core__mdarray_dump_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__mdarray_dump(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__arrayFlags
 LCC_RETURN wrapped_core__arrayFlags_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__arrayFlags(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__vref
 LCC_RETURN wrapped_core__vref_AbstractSimpleVector_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::AbstractSimpleVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__vref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__check_bound
 LCC_RETURN wrapped_core__check_bound_AbstractSimpleVector_spsize_tgc__Fixnum (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::AbstractSimpleVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<gc::Fixnum> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    Fixnum ret = core ::core__check_bound(a0._v,a1._v,a2._v);
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rowMajorAref
 LCC_RETURN wrapped_cl__rowMajorAref_Array_spgc__Fixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<gc::Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__rowMajorAref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayRowMajorIndex
 LCC_RETURN wrapped_cl__arrayRowMajorIndex_Array_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    size_t ret = core ::cl__arrayRowMajorIndex(a0._v,a1._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayElementType
 LCC_RETURN wrapped_cl__arrayElementType_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__arrayElementType(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__check_index
 LCC_RETURN wrapped_core__check_index_size_tsize_tsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__check_index(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__check_rank
 LCC_RETURN wrapped_core__check_rank_Array_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__check_rank(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__data_vector_p
 LCC_RETURN wrapped_core__data_vector_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__data_vector_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayDimension
 LCC_RETURN wrapped_cl__arrayDimension_Array_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    size_t ret = core ::cl__arrayDimension(a0._v,a1._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::cl__adjustable_array_p
 LCC_RETURN wrapped_cl__adjustable_array_p_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__adjustable_array_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__arrayDimensions
 LCC_RETURN wrapped_cl__arrayDimensions_Array_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Array_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::cl__arrayDimensions(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for ext::ext__maybeQuote
 LCC_RETURN wrapped_ext__maybeQuote_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = ext ::ext__maybeQuote(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__calculate_missing_common_lisp_symbols
 LCC_RETURN wrapped_core__calculate_missing_common_lisp_symbols_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__calculate_missing_common_lisp_symbols();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__remove_implementation_package
 LCC_RETURN wrapped_ext__remove_implementation_package_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::ext__remove_implementation_package(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::ext__add_implementation_package
 LCC_RETURN wrapped_ext__add_implementation_package_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::ext__add_implementation_package(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__package_name
 LCC_RETURN wrapped_cl__package_name_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__package_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__package_used_by_list
 LCC_RETURN wrapped_cl__package_used_by_list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::cl__package_used_by_list(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__package_use_list
 LCC_RETURN wrapped_cl__package_use_list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__package_use_list(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__gentemp
 LCC_RETURN wrapped_cl__gentemp_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__gentemp(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__shadowing_import
 LCC_RETURN wrapped_cl__shadowing_import_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__shadowing_import(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__package_documentation
 LCC_RETURN wrapped_core__package_documentation_Package_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Package_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__package_documentation(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__shadow
 LCC_RETURN wrapped_cl__shadow_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__shadow(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__import
 LCC_RETURN wrapped_cl__import_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__import(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__package_shadowing_symbols
 LCC_RETURN wrapped_cl__package_shadowing_symbols_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__package_shadowing_symbols(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__delete_package
 LCC_RETURN wrapped_cl__delete_package_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__delete_package(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__unuse_package
 LCC_RETURN wrapped_cl__unuse_package_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__unuse_package(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__use_package
 LCC_RETURN wrapped_cl__use_package_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__use_package(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__list_all_packages
 LCC_RETURN wrapped_cl__list_all_packages_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__list_all_packages();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_package
 LCC_RETURN wrapped_cl__make_package_T_spList_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Package_sp ret = core ::cl__make_package(a0._v,a1._v,a2._v);
     return translate::to_object<core::Package_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__find_symbol
 LCC_RETURN wrapped_cl__find_symbol_String_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__find_symbol(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__unintern
 LCC_RETURN wrapped_cl__unintern_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__unintern(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__call_with_package_read_write_lock
 LCC_RETURN wrapped_core__call_with_package_read_write_lock_Package_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Package_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__call_with_package_read_write_lock(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__call_with_package_read_lock
 LCC_RETURN wrapped_core__call_with_package_read_lock_Package_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Package_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__call_with_package_read_lock(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__package_local_nicknames_internal
 LCC_RETURN wrapped_core__package_local_nicknames_internal_Package_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Package_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__package_local_nicknames_internal(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__package_remove_nickname
 LCC_RETURN wrapped_ext__package_remove_nickname_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::ext__package_remove_nickname(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__package_add_nickname
 LCC_RETURN wrapped_ext__package_add_nickname_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::ext__package_add_nickname(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__package_nicknames
 LCC_RETURN wrapped_cl__package_nicknames_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__package_nicknames(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rename_package
 LCC_RETURN wrapped_cl__rename_package_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Package_sp ret = core ::cl__rename_package(a0._v,a1._v,a2._v);
     return translate::to_object<core::Package_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__package_implemented_by_list
 LCC_RETURN wrapped_ext__package_implemented_by_list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::ext__package_implemented_by_list(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__package_locked_p
 LCC_RETURN wrapped_ext__package_locked_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__package_locked_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::ext__unlock_package
 LCC_RETURN wrapped_ext__unlock_package_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Package_sp ret = core ::ext__unlock_package(a0._v);
     return translate::to_object<core::Package_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__lock_package
 LCC_RETURN wrapped_ext__lock_package_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Package_sp ret = core ::ext__lock_package(a0._v);
     return translate::to_object<core::Package_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cxxObjectP
 LCC_RETURN wrapped_core__cxxObjectP_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__cxxObjectP(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for ext::local_function_form_p
 LCC_RETURN wrapped_local_function_form_p_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = ext ::local_function_form_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__logical_pathname_p
 LCC_RETURN wrapped_core__logical_pathname_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__logical_pathname_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathnamep
 LCC_RETURN wrapped_cl__pathnamep_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__pathnamep(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_description_p
 LCC_RETURN wrapped_core__function_description_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__function_description_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__core_fun_generator_p
 LCC_RETURN wrapped_core__core_fun_generator_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__core_fun_generator_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__simple_core_fun_generator_p
 LCC_RETURN wrapped_core__simple_core_fun_generator_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__simple_core_fun_generator_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__proper_list_p
 LCC_RETURN wrapped_core__proper_list_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__proper_list_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__compiled_function_p
 LCC_RETURN wrapped_cl__compiled_function_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__compiled_function_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__simple_vector_p
 LCC_RETURN wrapped_cl__simple_vector_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__simple_vector_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__simple_bit_vector_p
 LCC_RETURN wrapped_cl__simple_bit_vector_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__simple_bit_vector_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__external_object_p
 LCC_RETURN wrapped_core__external_object_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__external_object_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__single_dispatch_generic_function_p
 LCC_RETURN wrapped_core__single_dispatch_generic_function_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__single_dispatch_generic_function_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__arrayp
 LCC_RETURN wrapped_core__arrayp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__arrayp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__readtablep
 LCC_RETURN wrapped_cl__readtablep_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__readtablep(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__hash_table_p
 LCC_RETURN wrapped_cl__hash_table_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__hash_table_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__bit_vector_p
 LCC_RETURN wrapped_cl__bit_vector_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__bit_vector_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__keywordp
 LCC_RETURN wrapped_cl__keywordp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__keywordp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__integerp
 LCC_RETURN wrapped_cl__integerp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__integerp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__vectorp
 LCC_RETURN wrapped_cl__vectorp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__vectorp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__floatp
 LCC_RETURN wrapped_cl__floatp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__floatp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__realp
 LCC_RETURN wrapped_cl__realp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__realp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__single_float_p
 LCC_RETURN wrapped_core__single_float_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__single_float_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__short_float_p
 LCC_RETURN wrapped_core__short_float_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__short_float_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__long_float_p
 LCC_RETURN wrapped_core__long_float_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__long_float_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rationalp
 LCC_RETURN wrapped_cl__rationalp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__rationalp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_p
 LCC_RETURN wrapped_core__source_pos_info_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__source_pos_info_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__random_state_p
 LCC_RETURN wrapped_cl__random_state_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__random_state_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__ratiop
 LCC_RETURN wrapped_core__ratiop_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__ratiop(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__complexp
 LCC_RETURN wrapped_cl__complexp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__complexp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__numberp
 LCC_RETURN wrapped_cl__numberp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__numberp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__instancep
 LCC_RETURN wrapped_core__instancep_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__instancep(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::clos__classp
 LCC_RETURN wrapped_clos__classp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::clos__classp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__packagep
 LCC_RETURN wrapped_cl__packagep_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__packagep(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__functionp
 LCC_RETURN wrapped_cl__functionp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__functionp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__double_float_p
 LCC_RETURN wrapped_core__double_float_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__double_float_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__extended_string_p
 LCC_RETURN wrapped_core__extended_string_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__extended_string_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__simple_string_p
 LCC_RETURN wrapped_cl__simple_string_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__simple_string_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__stringp
 LCC_RETURN wrapped_cl__stringp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__stringp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__base_string_p
 LCC_RETURN wrapped_core__base_string_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__base_string_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__bignump
 LCC_RETURN wrapped_core__bignump_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__bignump(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__base_char_p
 LCC_RETURN wrapped_core__base_char_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__base_char_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__generalp
 LCC_RETURN wrapped_core__generalp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__generalp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__subclassp
 LCC_RETURN wrapped_core__subclassp_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__subclassp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__compute_instance_creator
 LCC_RETURN wrapped_core__compute_instance_creator_T_spT_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__compute_instance_creator(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sjlj_throw
 LCC_RETURN wrapped_core__sjlj_throw_T_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__sjlj_throw(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__sjlj_catch_function
 LCC_RETURN wrapped_core__sjlj_catch_function_T_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__sjlj_catch_function(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sjlj_funwind_protect
 LCC_RETURN wrapped_core__sjlj_funwind_protect_Function_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__sjlj_funwind_protect(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sjlj_go
 LCC_RETURN wrapped_core__sjlj_go_TagbodyDynEnv_spsize_t (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::TagbodyDynEnv_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__sjlj_go(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__sjlj_ftagbody
 LCC_RETURN wrapped_core__sjlj_ftagbody_SimpleVector_sp (core::T_O* in0) {
    
    translate::from_object<core::SimpleVector_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__sjlj_ftagbody(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sjlj_escape
 LCC_RETURN wrapped_core__sjlj_escape_BlockDynEnv_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::BlockDynEnv_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__sjlj_escape(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__sjlj_call_with_escape_continuation
 LCC_RETURN wrapped_core__sjlj_call_with_escape_continuation_Function_sp (core::T_O* in0) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__sjlj_call_with_escape_continuation(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sjlj_call_with_variable_bound
 LCC_RETURN wrapped_core__sjlj_call_with_variable_bound_Symbol_spT_spFunction_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Function_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sjlj_call_with_variable_bound(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sjlj_call_with_unknown_dynenv
 LCC_RETURN wrapped_core__sjlj_call_with_unknown_dynenv_Function_sp (core::T_O* in0) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__sjlj_call_with_unknown_dynenv(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sjlj_dynenv_search
 LCC_RETURN wrapped_core__sjlj_dynenv_search_LexDynEnv_sp (core::T_O* in0) {
    
    translate::from_object<core::LexDynEnv_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = core ::core__sjlj_dynenv_search(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__sjlj_dynenv_search_one
 LCC_RETURN wrapped_core__sjlj_dynenv_search_one_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = core ::core__sjlj_dynenv_search_one(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__sjlj_call_with_current_dynenv
 LCC_RETURN wrapped_core__sjlj_call_with_current_dynenv_Function_sp (core::T_O* in0) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__sjlj_call_with_current_dynenv(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__wrong_index
 LCC_RETURN wrapped_core__wrong_index_const_string_intSymbol_spT_spintT_spint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<int> a6 (core::T_sp((gc::Tagged)(in6)));
                     
    core ::core__wrong_index(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__wrong_type_nth_arg
 LCC_RETURN wrapped_core__wrong_type_nth_arg_const_string_intSymbol_spintT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core ::core__wrong_type_nth_arg(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__wrong_type_argument
 LCC_RETURN wrapped_core__wrong_type_argument_const_string_intSymbol_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core ::core__wrong_type_argument(a0._v,a1._v,a2._v,a3._v,a4._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__function_wrong_type_argument
 LCC_RETURN wrapped_core__function_wrong_type_argument_Symbol_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__function_wrong_type_argument(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__add_debug_filename
 LCC_RETURN wrapped_core__add_debug_filename_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__add_debug_filename(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__signal_simple_error
 LCC_RETURN wrapped_core__signal_simple_error_T_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::core__signal_simple_error(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__command_line_load_eval_sequence
 LCC_RETURN wrapped_core__command_line_load_eval_sequence_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = core ::core__command_line_load_eval_sequence();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__translate_logical_pathname
 LCC_RETURN wrapped_cl__translate_logical_pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::cl__translate_logical_pathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__translate_pathname
 LCC_RETURN wrapped_cl__translate_pathname_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::Pathname_sp ret = core ::cl__translate_pathname(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_match_p
 LCC_RETURN wrapped_cl__pathname_match_p_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__pathname_match_p(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__enough_namestring
 LCC_RETURN wrapped_cl__enough_namestring_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__enough_namestring(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__host_namestring
 LCC_RETURN wrapped_cl__host_namestring_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__host_namestring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__directory_namestring
 LCC_RETURN wrapped_cl__directory_namestring_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__directory_namestring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_namestring
 LCC_RETURN wrapped_cl__file_namestring_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__file_namestring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_version
 LCC_RETURN wrapped_cl__pathname_version_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__pathname_version(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_type
 LCC_RETURN wrapped_cl__pathname_type_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__pathname_type(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_name
 LCC_RETURN wrapped_cl__pathname_name_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__pathname_name(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_directory
 LCC_RETURN wrapped_cl__pathname_directory_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__pathname_directory(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_device
 LCC_RETURN wrapped_cl__pathname_device_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__pathname_device(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname_host
 LCC_RETURN wrapped_cl__pathname_host_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__pathname_host(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_pathname
 LCC_RETURN wrapped_cl__make_pathname_T_spboolT_spboolT_spboolT_spboolT_spboolT_spboolT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8,core::T_O* in9,core::T_O* in10,core::T_O* in11,core::T_O* in12,core::T_O* in13) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::T_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<bool> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<core::T_sp> a8 (core::T_sp((gc::Tagged)(in8)));
                     translate::from_object<bool> a9 (core::T_sp((gc::Tagged)(in9)));
                     translate::from_object<core::T_sp> a10 (core::T_sp((gc::Tagged)(in10)));
                     translate::from_object<bool> a11 (core::T_sp((gc::Tagged)(in11)));
                     translate::from_object<core::T_sp> a12 (core::T_sp((gc::Tagged)(in12)));
                     translate::from_object<core::T_sp> a13 (core::T_sp((gc::Tagged)(in13)));
                     
    core::Pathname_sp ret = core ::cl__make_pathname(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v,a9._v,a10._v,a11._v,a12._v,a13._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__parse_namestring
 LCC_RETURN wrapped_cl__parse_namestring_T_spT_spT_spFixnum_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Fixnum_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    auto ret = core ::cl__parse_namestring(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__namestring
 LCC_RETURN wrapped_cl__namestring_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__namestring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_to_filename
 LCC_RETURN wrapped_core__coerce_to_filename_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::core__coerce_to_filename(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_to_physical_pathname
 LCC_RETURN wrapped_core__coerce_to_physical_pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::core__coerce_to_physical_pathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__coerce_to_file_pathname
 LCC_RETURN wrapped_core__coerce_to_file_pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::core__coerce_to_file_pathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__wild_pathname_p
 LCC_RETURN wrapped_cl__wild_pathname_p_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__wild_pathname_p(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__merge_pathnames
 LCC_RETURN wrapped_cl__merge_pathnames_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Pathname_sp ret = core ::cl__merge_pathnames(a0._v,a1._v,a2._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logical_pathname
 LCC_RETURN wrapped_cl__logical_pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__logical_pathname(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pathname
 LCC_RETURN wrapped_cl__pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::cl__pathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::gray__PERCENTpathname
 LCC_RETURN wrapped_gray__PERCENTpathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::gray__PERCENTpathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__safe_default_pathname_defaults_host_only
 LCC_RETURN wrapped_core__safe_default_pathname_defaults_host_only_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Pathname_sp ret = core ::core__safe_default_pathname_defaults_host_only();
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__safe_default_pathname_defaults
 LCC_RETURN wrapped_core__safe_default_pathname_defaults_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Pathname_sp ret = core ::core__safe_default_pathname_defaults();
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__list_all_logical_hosts
 LCC_RETURN wrapped_core__list_all_logical_hosts_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__list_all_logical_hosts();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__logical_host_p
 LCC_RETURN wrapped_core__logical_host_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__logical_host_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logical_pathname_translations
 LCC_RETURN wrapped_cl__logical_pathname_translations_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::cl__logical_pathname_translations(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__float_to_digits
 LCC_RETURN wrapped_core__float_to_digits_T_spFloat_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Float_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = core ::core__float_to_digits(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_vertical_bar
 LCC_RETURN wrapped_core__sharp_vertical_bar_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_vertical_bar(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_minus
 LCC_RETURN wrapped_core__sharp_minus_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_minus(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_plus
 LCC_RETURN wrapped_core__sharp_plus_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_plus(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_feature_p
 LCC_RETURN wrapped_core__reader_feature_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__reader_feature_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sharp_p
 LCC_RETURN wrapped_core__sharp_p_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_p(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_s
 LCC_RETURN wrapped_core__sharp_s_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_s(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_a
 LCC_RETURN wrapped_core__sharp_a_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_a(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_c
 LCC_RETURN wrapped_core__sharp_c_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_c(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_x
 LCC_RETURN wrapped_core__sharp_x_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_x(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_o
 LCC_RETURN wrapped_core__sharp_o_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_o(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_b
 LCC_RETURN wrapped_core__sharp_b_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_b(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_r
 LCC_RETURN wrapped_core__sharp_r_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_r(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_colon
 LCC_RETURN wrapped_core__sharp_colon_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_colon(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_asterisk
 LCC_RETURN wrapped_core__sharp_asterisk_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_asterisk(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_foreign_data_reader
 LCC_RETURN wrapped_core__sharp_foreign_data_reader_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_foreign_data_reader(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_left_parenthesis
 LCC_RETURN wrapped_core__sharp_left_parenthesis_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_left_parenthesis(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_single_quote
 LCC_RETURN wrapped_core__sharp_single_quote_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__sharp_single_quote(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sharp_dot
 LCC_RETURN wrapped_core__sharp_dot_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_dot(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sharp_backslash
 LCC_RETURN wrapped_core__sharp_backslash_T_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sharp_backslash(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__dispatch_macro_character
 LCC_RETURN wrapped_core__dispatch_macro_character_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__dispatch_macro_character(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_skip_semicolon_comment
 LCC_RETURN wrapped_core__reader_skip_semicolon_comment_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__reader_skip_semicolon_comment(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_quote
 LCC_RETURN wrapped_core__reader_quote_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__reader_quote(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__reader_error_unmatched_close_parenthesis
 LCC_RETURN wrapped_core__reader_error_unmatched_close_parenthesis_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__reader_error_unmatched_close_parenthesis(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_list_allow_consing_dot
 LCC_RETURN wrapped_core__reader_list_allow_consing_dot_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__reader_list_allow_consing_dot(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__reader_comma_form
 LCC_RETURN wrapped_core__reader_comma_form_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__reader_comma_form(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__reader_error_backquote_context
 LCC_RETURN wrapped_core__reader_error_backquote_context_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__reader_error_backquote_context(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_backquoted_expression
 LCC_RETURN wrapped_core__reader_backquoted_expression_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__reader_backquoted_expression(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__reader_double_quote_string
 LCC_RETURN wrapped_core__reader_double_quote_string_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__reader_double_quote_string(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_syntax_type
 LCC_RETURN wrapped_core__setf_syntax_type_T_spT_spCharacter_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Character_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__setf_syntax_type(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__syntax_type
 LCC_RETURN wrapped_core__syntax_type_T_spCharacter_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__syntax_type(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set_macro_character
 LCC_RETURN wrapped_cl__set_macro_character_Character_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__set_macro_character(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get_dispatch_macro_character
 LCC_RETURN wrapped_cl__get_dispatch_macro_character_Character_spCharacter_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__get_dispatch_macro_character(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set_dispatch_macro_character
 LCC_RETURN wrapped_cl__set_dispatch_macro_character_Character_spCharacter_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__set_dispatch_macro_character(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__readtable_case
 LCC_RETURN wrapped_cl__readtable_case_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__readtable_case(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__copy_readtable
 LCC_RETURN wrapped_cl__copy_readtable_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__copy_readtable(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get_macro_character
 LCC_RETURN wrapped_cl__get_macro_character_Character_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__get_macro_character(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__make_dispatch_macro_character
 LCC_RETURN wrapped_cl__make_dispatch_macro_character_Character_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__make_dispatch_macro_character(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set_syntax_from_char
 LCC_RETURN wrapped_cl__set_syntax_from_char_Character_spCharacter_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Character_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::cl__set_syntax_from_char(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__wrapped_stamp
 LCC_RETURN wrapped_core__wrapped_stamp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__wrapped_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_wrapped_pointer_layout
 LCC_RETURN wrapped_core__verify_wrapped_pointer_layout_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__verify_wrapped_pointer_layout(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__write_ugly_object
 LCC_RETURN wrapped_core__write_ugly_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__write_ugly_object(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__all_source_files
 LCC_RETURN wrapped_core__all_source_files_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = core ::core__all_source_files();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__not
 LCC_RETURN wrapped_cl__not_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__not(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__repr
 LCC_RETURN wrapped_core__repr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__repr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__breakstepping_p
 LCC_RETURN wrapped_core__breakstepping_p_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__breakstepping_p();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__unset_breakstep
 LCC_RETURN wrapped_core__unset_breakstep_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__unset_breakstep();
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_breakstep
 LCC_RETURN wrapped_core__set_breakstep_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__set_breakstep();
     return Values0<core::T_O>();
    }
// Generating code for core::cl__cerror
 LCC_RETURN wrapped_cl__cerror_T_spT_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__cerror(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__error
 LCC_RETURN wrapped_cl__error_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::cl__error(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__invoke_internal_debugger_from_gdb
 LCC_RETURN wrapped_core__invoke_internal_debugger_from_gdb_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__invoke_internal_debugger_from_gdb();
     return Values0<core::T_O>();
    }
// Generating code for core::core__invoke_internal_debugger
 LCC_RETURN wrapped_core__invoke_internal_debugger_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__invoke_internal_debugger(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__universal_error_handler
 LCC_RETURN wrapped_core__universal_error_handler_T_spT_spList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__universal_error_handler(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__intern
 LCC_RETURN wrapped_cl__intern_String_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__intern(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__unexport
 LCC_RETURN wrapped_cl__unexport_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__unexport(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__export
 LCC_RETURN wrapped_cl__export_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__export(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debug_log_off
 LCC_RETURN wrapped_core__debug_log_off_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__debug_log_off();
     return Values0<core::T_O>();
    }
// Generating code for core::core__debug_log_on
 LCC_RETURN wrapped_core__debug_log_on_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__debug_log_on();
     return Values0<core::T_O>();
    }
// Generating code for core::cl__sort
 LCC_RETURN wrapped_cl__sort_List_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__sort(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__apropos
 LCC_RETURN wrapped_cl__apropos_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__apropos(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__macroexpand
 LCC_RETURN wrapped_cl__macroexpand_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__macroexpand(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__macroexpand_1
 LCC_RETURN wrapped_cl__macroexpand_1_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__macroexpand_1(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__mpi_size
 LCC_RETURN wrapped_core__mpi_size_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__mpi_size();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mpi_rank
 LCC_RETURN wrapped_core__mpi_rank_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__mpi_rank();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mpi_enabled
 LCC_RETURN wrapped_core__mpi_enabled_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__mpi_enabled();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__select_package
 LCC_RETURN wrapped_core__select_package_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__select_package(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__find_package_global
 LCC_RETURN wrapped_core__find_package_global_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__find_package_global(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__find_package
 LCC_RETURN wrapped_cl__find_package_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__find_package(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__find_file_in_lisp_path
 LCC_RETURN wrapped_core__find_file_in_lisp_path_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__find_file_in_lisp_path(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_find_class
 LCC_RETURN wrapped_core__setf_find_class_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__setf_find_class(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__find_class
 LCC_RETURN wrapped_cl__find_class_Symbol_spboolT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__find_class(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__find_class_holder
 LCC_RETURN wrapped_core__find_class_holder_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::ClassHolder_sp ret = core ::core__find_class_holder(a0._v,a1._v);
     return translate::to_object<core::ClassHolder_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__lookup_class_with_stamp
 LCC_RETURN wrapped_core__lookup_class_with_stamp_Fixnum (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__lookup_class_with_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__getline
 LCC_RETURN wrapped_core__getline_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__getline(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__member1
 LCC_RETURN wrapped_core__member1_T_spList_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::List_sp ret = core ::core__member1(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__adjoin
 LCC_RETURN wrapped_cl__adjoin_T_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::List_sp ret = core ::cl__adjoin(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__member
 LCC_RETURN wrapped_cl__member_T_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::List_sp ret = core ::cl__member(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__assoc
 LCC_RETURN wrapped_cl__assoc_T_spList_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::List_sp ret = core ::cl__assoc(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__acons
 LCC_RETURN wrapped_cl__acons_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::List_sp ret = core ::cl__acons(a0._v,a1._v,a2._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cabort
 LCC_RETURN wrapped_core__cabort_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__cabort();
     return Values0<core::T_O>();
    }
// Generating code for core::core__quit
 LCC_RETURN wrapped_core__quit_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__quit(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__c_UNDERSCORE_exit
 LCC_RETURN wrapped_core__c_UNDERSCORE_exit_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__c_UNDERSCORE_exit(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__cexit
 LCC_RETURN wrapped_core__cexit_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__cexit(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__exit
 LCC_RETURN wrapped_core__exit_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__exit(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__stack_limit
 LCC_RETURN wrapped_core__stack_limit_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__stack_limit();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__no_rc_p
 LCC_RETURN wrapped_core__no_rc_p_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__no_rc_p();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__rc_file_name
 LCC_RETURN wrapped_core__rc_file_name_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::String_sp ret = core ::core__rc_file_name();
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__is_interactive_lisp
 LCC_RETURN wrapped_core__is_interactive_lisp_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__is_interactive_lisp();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_disabled_p
 LCC_RETURN wrapped_core__debugger_disabled_p_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__debugger_disabled_p();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::ext__disable_debugger
 LCC_RETURN wrapped_ext__disable_debugger_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::ext__disable_debugger();
     return Values0<core::T_O>();
    }
// Generating code for core::ext__enable_debugger
 LCC_RETURN wrapped_ext__enable_debugger_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::ext__enable_debugger();
     return Values0<core::T_O>();
    }
// Generating code for core::core__noprint_p
 LCC_RETURN wrapped_core__noprint_p_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__noprint_p();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__noinform_p
 LCC_RETURN wrapped_core__noinform_p_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__noinform_p();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__startup_type
 LCC_RETURN wrapped_core__startup_type_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__startup_type();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__singleDispatchGenericFunctions
 LCC_RETURN wrapped_core__singleDispatchGenericFunctions_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = core ::core__singleDispatchGenericFunctions();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__low_level_repl
 LCC_RETURN wrapped_core__low_level_repl_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__low_level_repl();
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_debug_start_code
 LCC_RETURN wrapped_core__set_debug_start_code_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_debug_start_code(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__monitor_write
 LCC_RETURN wrapped_core__monitor_write_const_std__string_ (core::T_O* in0) {
    
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__monitor_write(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__monitor_directory
 LCC_RETURN wrapped_core__monitor_directory_ () {
    
    
    std::string ret = core ::core__monitor_directory();
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lognor
 LCC_RETURN wrapped_cl__lognor_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__lognor(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lognand
 LCC_RETURN wrapped_cl__lognand_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__lognand(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lognot
 LCC_RETURN wrapped_cl__lognot_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__lognot(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logorc2
 LCC_RETURN wrapped_cl__logorc2_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__logorc2(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logorc1
 LCC_RETURN wrapped_cl__logorc1_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__logorc1(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logandc2
 LCC_RETURN wrapped_cl__logandc2_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__logandc2(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logandc1
 LCC_RETURN wrapped_cl__logandc1_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__logandc1(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logeqv
 LCC_RETURN wrapped_cl__logeqv_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__logeqv(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logxor
 LCC_RETURN wrapped_cl__logxor_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__logxor(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logior
 LCC_RETURN wrapped_cl__logior_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__logior(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logand
 LCC_RETURN wrapped_cl__logand_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__logand(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__logeqv_2op
 LCC_RETURN wrapped_core__logeqv_2op_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__logeqv_2op(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__logior_2op
 LCC_RETURN wrapped_core__logior_2op_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__logior_2op(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__logxor_2op
 LCC_RETURN wrapped_core__logxor_2op_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__logxor_2op(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__logand_2op
 LCC_RETURN wrapped_core__logand_2op_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__logand_2op(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__boole
 LCC_RETURN wrapped_cl__boole_FixnumInteger_spInteger_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Integer_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__boole(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logbitp
 LCC_RETURN wrapped_cl__logbitp_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__logbitp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::TwoWayStream_O::output_stream
 LCC_RETURN wrapped_TwoWayStream_O__output_stream_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::TwoWayStream_O::output_stream(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::TwoWayStream_O::input_stream
 LCC_RETURN wrapped_TwoWayStream_O__input_stream_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::TwoWayStream_O::input_stream(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::TwoWayStream_O::make
 LCC_RETURN wrapped_TwoWayStream_O__make_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::TwoWayStream_sp ret = core ::TwoWayStream_O::make(a0._v,a1._v);
     return translate::to_object<core::TwoWayStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::SynonymStream_O::symbol
 LCC_RETURN wrapped_SynonymStream_O__symbol_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::SynonymStream_O::symbol(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::SynonymStream_O::make
 LCC_RETURN wrapped_SynonymStream_O__make_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SynonymStream_sp ret = core ::SynonymStream_O::make(a0._v);
     return translate::to_object<core::SynonymStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__get_thread_local_write_to_string_output_stream_string
 LCC_RETURN wrapped_core__get_thread_local_write_to_string_output_stream_string_StringOutputStream_sp (core::T_O* in0) {
    
    translate::from_object<core::StringOutputStream_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::core__get_thread_local_write_to_string_output_stream_string(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__thread_local_write_to_string_output_stream
 LCC_RETURN wrapped_core__thread_local_write_to_string_output_stream_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::StringOutputStream_sp ret = core ::core__thread_local_write_to_string_output_stream();
     return translate::to_object<core::StringOutputStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::StringOutputStream_O::get_string
 LCC_RETURN wrapped_StringOutputStream_O__get_string_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::StringOutputStream_O::get_string(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_string_output_stream
 LCC_RETURN wrapped_cl__make_string_output_stream_Symbol_sp (core::T_O* in0) {
    
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::StringOutputStream_sp ret = core ::cl__make_string_output_stream(a0._v);
     return translate::to_object<core::StringOutputStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_string_output_stream_from_string
 LCC_RETURN wrapped_core__make_string_output_stream_from_string_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::StringOutputStream_sp ret = core ::core__make_string_output_stream_from_string(a0._v);
     return translate::to_object<core::StringOutputStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::EchoStream_O::output_stream
 LCC_RETURN wrapped_EchoStream_O__output_stream_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::EchoStream_O::output_stream(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::EchoStream_O::input_stream
 LCC_RETURN wrapped_EchoStream_O__input_stream_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::EchoStream_O::input_stream(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::EchoStream_O::make
 LCC_RETURN wrapped_EchoStream_O__make_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::EchoStream_sp ret = core ::EchoStream_O::make(a0._v,a1._v);
     return translate::to_object<core::EchoStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ConcatenatedStream_O::streams
 LCC_RETURN wrapped_ConcatenatedStream_O__streams_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::ConcatenatedStream_O::streams(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ConcatenatedStream_O::make
 LCC_RETURN wrapped_ConcatenatedStream_O__make_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::ConcatenatedStream_sp ret = core ::ConcatenatedStream_O::make(a0._v);
     return translate::to_object<core::ConcatenatedStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::BroadcastStream_O::streams
 LCC_RETURN wrapped_BroadcastStream_O__streams_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::BroadcastStream_O::streams(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::BroadcastStream_O::make
 LCC_RETURN wrapped_BroadcastStream_O__make_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::BroadcastStream_sp ret = core ::BroadcastStream_O::make(a0._v);
     return translate::to_object<core::BroadcastStream_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__input_stream_source_pos_info
 LCC_RETURN wrapped_core__input_stream_source_pos_info_T_spFileScope_spsize_tsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::FileScope_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::SourcePosInfo_sp ret = core ::core__input_stream_source_pos_info(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::SourcePosInfo_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__stream_input_column
 LCC_RETURN wrapped_core__stream_input_column_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uint ret = core ::core__stream_input_column(a0._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for core::core__stream_input_line
 LCC_RETURN wrapped_core__stream_input_line_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uint ret = core ::core__stream_input_line(a0._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_string_input_stream
 LCC_RETURN wrapped_cl__make_string_input_stream_String_spcl_indexT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<cl_index> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__make_string_input_stream(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_fd_stream
 LCC_RETURN wrapped_core__make_fd_stream_intcore__StreamDirection (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::StreamDirection> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__make_fd_stream(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__lseek
 LCC_RETURN wrapped_core__lseek_intint64_tSymbol_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int64_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Symbol_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    int64_t ret = core ::core__lseek(a0._v,a1._v,a2._v);
     return translate::to_object<int64_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__close_fd
 LCC_RETURN wrapped_core__close_fd_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__close_fd(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__fcntl_non_blocking
 LCC_RETURN wrapped_core__fcntl_non_blocking_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__fcntl_non_blocking(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__write_c_uint16
 LCC_RETURN wrapped_core__write_c_uint16_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__write_c_uint16(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__write_c_uint32
 LCC_RETURN wrapped_core__write_c_uint32_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__write_c_uint32(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__write_ieee_single_float
 LCC_RETURN wrapped_core__write_ieee_single_float_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__write_ieee_single_float(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__read_binary_single_float
 LCC_RETURN wrapped_core__read_binary_single_float_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__read_binary_single_float(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__read_dense_specialized_array
 LCC_RETURN wrapped_core__read_dense_specialized_array_T_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__read_dense_specialized_array(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__read_fd
 LCC_RETURN wrapped_core__read_fd_intSimpleBaseString_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleBaseString_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__read_fd(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__write_sequence
 LCC_RETURN wrapped_cl__write_sequence_T_spT_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__write_sequence(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__stream_output_line
 LCC_RETURN wrapped_core__stream_output_line_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uint ret = core ::core__stream_output_line(a0._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for core::core__stream_output_column
 LCC_RETURN wrapped_core__stream_output_column_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uint ret = core ::core__stream_output_column(a0._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for core::cl__unread_char
 LCC_RETURN wrapped_cl__unread_char_Character_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__unread_char(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__finish_output
 LCC_RETURN wrapped_cl__finish_output_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__finish_output(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__force_output
 LCC_RETURN wrapped_cl__force_output_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__force_output(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__listen
 LCC_RETURN wrapped_cl__listen_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__listen(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__clear_output
 LCC_RETURN wrapped_cl__clear_output_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__clear_output(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__clear_input
 LCC_RETURN wrapped_cl__clear_input_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__clear_input(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__write_char_beta
 LCC_RETURN wrapped_core__write_char_beta_Character_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Character_sp ret = core ::core__write_char_beta(a0._v,a1._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__write_char
 LCC_RETURN wrapped_cl__write_char_Character_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Character_sp ret = core ::cl__write_char(a0._v,a1._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__write_byte
 LCC_RETURN wrapped_cl__write_byte_Integer_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__write_byte(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__write_line
 LCC_RETURN wrapped_cl__write_line_String_spT_spintT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::String_sp ret = core ::cl__write_line(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__write_string
 LCC_RETURN wrapped_cl__write_string_String_spT_spintT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::String_sp ret = core ::cl__write_string(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__fresh_line
 LCC_RETURN wrapped_cl__fresh_line_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__fresh_line(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__terpri
 LCC_RETURN wrapped_cl__terpri_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::cl__terpri(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__read_line
 LCC_RETURN wrapped_cl__read_line_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = core ::cl__read_line(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__read_from_string
 LCC_RETURN wrapped_cl__read_from_string_String_spT_spT_spFixnum_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Fixnum_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    auto ret = core ::cl__read_from_string(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__read_char_no_hang
 LCC_RETURN wrapped_cl__read_char_no_hang_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__read_char_no_hang(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read_char
 LCC_RETURN wrapped_cl__read_char_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__read_char(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__peek_char
 LCC_RETURN wrapped_cl__peek_char_T_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::cl__peek_char(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read_byte
 LCC_RETURN wrapped_cl__read_byte_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::cl__read_byte(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__copy_stream
 LCC_RETURN wrapped_core__copy_stream_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__copy_stream(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__close
 LCC_RETURN wrapped_cl__close_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__close(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__open
 LCC_RETURN wrapped_cl__open_T_spcore__StreamDirectionT_spcore__StreamIfExistsboolcore__StreamIfDoesNotExistboolT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::StreamDirection> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::StreamIfExists> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::StreamIfDoesNotExist> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<bool> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<core::T_sp> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<core::T_sp> a8 (core::T_sp((gc::Tagged)(in8)));
                     
    core::T_sp ret = core ::cl__open(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__streamp
 LCC_RETURN wrapped_cl__streamp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__streamp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__stream_external_format
 LCC_RETURN wrapped_cl__stream_external_format_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__stream_external_format(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__stream_element_type
 LCC_RETURN wrapped_cl__stream_element_type_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__stream_element_type(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__open_stream_p
 LCC_RETURN wrapped_cl__open_stream_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__open_stream_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__interactive_stream_p
 LCC_RETURN wrapped_cl__interactive_stream_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__interactive_stream_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__output_stream_p
 LCC_RETURN wrapped_cl__output_stream_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__output_stream_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__input_stream_p
 LCC_RETURN wrapped_cl__input_stream_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__input_stream_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__make_stream_from_fd
 LCC_RETURN wrapped_ext__make_stream_from_fd_intcore__StreamDirectionT_spT_spT_spString_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::StreamDirection> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::String_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::ext__make_stream_from_fd(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_position
 LCC_RETURN wrapped_cl__file_position_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__file_position(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_length
 LCC_RETURN wrapped_cl__file_length_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__file_length(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read_sequence
 LCC_RETURN wrapped_cl__read_sequence_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__read_sequence(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_string_length
 LCC_RETURN wrapped_cl__file_string_length_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__file_string_length(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__write_addr
 LCC_RETURN wrapped_core__write_addr_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__write_addr(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__file_stream_fd
 LCC_RETURN wrapped_core__file_stream_fd_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__file_stream_fd(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__file_stream_file_descriptor
 LCC_RETURN wrapped_ext__file_stream_file_descriptor_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::ext__file_stream_file_descriptor(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_file_descriptor
 LCC_RETURN wrapped_stream_file_descriptor_T_spcore__StreamDirection (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::StreamDirection> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = core ::stream_file_descriptor(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::stream_input_line
 LCC_RETURN wrapped_stream_input_line_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_input_line(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_input_column
 LCC_RETURN wrapped_stream_input_column_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_input_column(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_output_line
 LCC_RETURN wrapped_stream_output_line_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_output_line(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_start_line_p
 LCC_RETURN wrapped_stream_start_line_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::stream_start_line_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_output_column
 LCC_RETURN wrapped_stream_output_column_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_output_column(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_set_external_format
 LCC_RETURN wrapped_stream_set_external_format_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::stream_set_external_format(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_external_format
 LCC_RETURN wrapped_stream_external_format_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_external_format(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_set_element_type
 LCC_RETURN wrapped_stream_set_element_type_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::stream_set_element_type(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_element_type
 LCC_RETURN wrapped_stream_element_type_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::stream_element_type(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::stream_interactive_p
 LCC_RETURN wrapped_stream_interactive_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::stream_interactive_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_output_p
 LCC_RETURN wrapped_stream_output_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::stream_output_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_input_p
 LCC_RETURN wrapped_stream_input_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::stream_input_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_open_p
 LCC_RETURN wrapped_stream_open_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::stream_open_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_advance_to_column
 LCC_RETURN wrapped_stream_advance_to_column_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::stream_advance_to_column(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::stream_close
 LCC_RETURN wrapped_stream_close_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::stream_close(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__process_single_dispatch_lambda_list
 LCC_RETURN wrapped_core__process_single_dispatch_lambda_list_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__process_single_dispatch_lambda_list(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__process_macro_lambda_list
 LCC_RETURN wrapped_core__process_macro_lambda_list_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__process_macro_lambda_list(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__process_lambda_list
 LCC_RETURN wrapped_core__process_lambda_list_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__process_lambda_list(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__canonicalize_declarations
 LCC_RETURN wrapped_core__canonicalize_declarations_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__canonicalize_declarations(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__is_a_type
 LCC_RETURN wrapped_core__is_a_type_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__is_a_type(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__mangledSymbols
 LCC_RETURN wrapped_core__mangledSymbols_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__mangledSymbols(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__debug_only_set_badge
 LCC_RETURN wrapped_core__debug_only_set_badge_T_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__debug_only_set_badge(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__get_badge
 LCC_RETURN wrapped_core__get_badge_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__get_badge(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_drag_general_allocation_delay
 LCC_RETURN wrapped_core__set_drag_general_allocation_delay_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_drag_general_allocation_delay(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_drag_cons_allocation_delay
 LCC_RETURN wrapped_core__set_drag_cons_allocation_delay_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_drag_cons_allocation_delay(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_drag_interpret_dtree_delay
 LCC_RETURN wrapped_core__set_drag_interpret_dtree_delay_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_drag_interpret_dtree_delay(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_drag_native_calls_delay
 LCC_RETURN wrapped_core__set_drag_native_calls_delay_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_drag_native_calls_delay(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_drag_cxx_calls_delay
 LCC_RETURN wrapped_core__set_drag_cxx_calls_delay_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__set_drag_cxx_calls_delay(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__magic_name
 LCC_RETURN wrapped_core__magic_name_const_std__string_const_std__string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const std::string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__magic_name(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__magic_disassemble_and_intern
 LCC_RETURN wrapped_core__magic_disassemble_and_intern_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__magic_disassemble_and_intern(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__magic_intern
 LCC_RETURN wrapped_core__magic_intern_const_string_const_string_ (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<const string&> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Symbol_sp ret = core ::core__magic_intern(a0._v,a1._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__lispify_name
 LCC_RETURN wrapped_core__lispify_name_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::String_sp ret = core ::core__lispify_name(a0._v);
     return translate::to_object<core::String_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__dump_class_ids
 LCC_RETURN wrapped_core__dump_class_ids_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__dump_class_ids();
     return Values0<core::T_O>();
    }
// Generating code for clasp_ffi::PERCENTget_section_data
 LCC_RETURN wrapped_PERCENTget_section_data_core__String_spcore__String_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = clasp_ffi ::PERCENTget_section_data(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_unsigned_char
 LCC_RETURN wrapped_PERCENTmem_set_unsigned_char_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_unsigned_char(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_char
 LCC_RETURN wrapped_PERCENTmem_set_char_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_char(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_ptrdiff
 LCC_RETURN wrapped_PERCENTmem_set_ptrdiff_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_ptrdiff(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_ssize
 LCC_RETURN wrapped_PERCENTmem_set_ssize_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_ssize(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_size
 LCC_RETURN wrapped_PERCENTmem_set_size_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_size(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_pointer
 LCC_RETURN wrapped_PERCENTmem_set_pointer_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_pointer(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_time
 LCC_RETURN wrapped_PERCENTmem_set_time_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_time(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_long_double
 LCC_RETURN wrapped_PERCENTmem_set_long_double_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_long_double(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_float
 LCC_RETURN wrapped_PERCENTmem_set_float_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_float(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_double
 LCC_RETURN wrapped_PERCENTmem_set_double_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_double(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_unsigned_long_long
 LCC_RETURN wrapped_PERCENTmem_set_unsigned_long_long_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_unsigned_long_long(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_long_long
 LCC_RETURN wrapped_PERCENTmem_set_long_long_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_long_long(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_unsigned_long
 LCC_RETURN wrapped_PERCENTmem_set_unsigned_long_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_unsigned_long(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_long
 LCC_RETURN wrapped_PERCENTmem_set_long_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_long(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_uint64
 LCC_RETURN wrapped_PERCENTmem_set_uint64_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_uint64(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_int64
 LCC_RETURN wrapped_PERCENTmem_set_int64_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_int64(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_uint32
 LCC_RETURN wrapped_PERCENTmem_set_uint32_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_uint32(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_int32
 LCC_RETURN wrapped_PERCENTmem_set_int32_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_int32(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_uint16
 LCC_RETURN wrapped_PERCENTmem_set_uint16_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_uint16(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_int16
 LCC_RETURN wrapped_PERCENTmem_set_int16_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_int16(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_uint8
 LCC_RETURN wrapped_PERCENTmem_set_uint8_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_uint8(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_int8
 LCC_RETURN wrapped_PERCENTmem_set_int8_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_int8(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_unsigned_int
 LCC_RETURN wrapped_PERCENTmem_set_unsigned_int_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_unsigned_int(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_int
 LCC_RETURN wrapped_PERCENTmem_set_int_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_int(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_unsigned_short
 LCC_RETURN wrapped_PERCENTmem_set_unsigned_short_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_unsigned_short(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_set_short
 LCC_RETURN wrapped_PERCENTmem_set_short_core__Integer_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_set_short(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_unsigned_char
 LCC_RETURN wrapped_PERCENTmem_ref_unsigned_char_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_unsigned_char(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_char
 LCC_RETURN wrapped_PERCENTmem_ref_char_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_char(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_ptrdiff
 LCC_RETURN wrapped_PERCENTmem_ref_ptrdiff_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_ptrdiff(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_ssize
 LCC_RETURN wrapped_PERCENTmem_ref_ssize_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_ssize(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_size
 LCC_RETURN wrapped_PERCENTmem_ref_size_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_size(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_pointer
 LCC_RETURN wrapped_PERCENTmem_ref_pointer_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_pointer(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_time
 LCC_RETURN wrapped_PERCENTmem_ref_time_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_time(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_long_double
 LCC_RETURN wrapped_PERCENTmem_ref_long_double_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_long_double(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_float
 LCC_RETURN wrapped_PERCENTmem_ref_float_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_float(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_double
 LCC_RETURN wrapped_PERCENTmem_ref_double_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_double(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_unsigned_long_long
 LCC_RETURN wrapped_PERCENTmem_ref_unsigned_long_long_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_unsigned_long_long(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_long_long
 LCC_RETURN wrapped_PERCENTmem_ref_long_long_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_long_long(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_unsigned_long
 LCC_RETURN wrapped_PERCENTmem_ref_unsigned_long_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_unsigned_long(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_long
 LCC_RETURN wrapped_PERCENTmem_ref_long_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_long(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_uint64
 LCC_RETURN wrapped_PERCENTmem_ref_uint64_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_uint64(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_int64
 LCC_RETURN wrapped_PERCENTmem_ref_int64_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_int64(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_uint32
 LCC_RETURN wrapped_PERCENTmem_ref_uint32_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_uint32(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_int32
 LCC_RETURN wrapped_PERCENTmem_ref_int32_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_int32(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_uint16
 LCC_RETURN wrapped_PERCENTmem_ref_uint16_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_uint16(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_int16
 LCC_RETURN wrapped_PERCENTmem_ref_int16_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_int16(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_uint8
 LCC_RETURN wrapped_PERCENTmem_ref_uint8_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_uint8(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_int8
 LCC_RETURN wrapped_PERCENTmem_ref_int8_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_int8(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_unsigned_int
 LCC_RETURN wrapped_PERCENTmem_ref_unsigned_int_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_unsigned_int(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_int
 LCC_RETURN wrapped_PERCENTmem_ref_int_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_int(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_unsigned_short
 LCC_RETURN wrapped_PERCENTmem_ref_unsigned_short_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_unsigned_short(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmem_ref_short
 LCC_RETURN wrapped_PERCENTmem_ref_short_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTmem_ref_short(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTdlsym
 LCC_RETURN wrapped_PERCENTdlsym_core__T_spcore__String_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTdlsym(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTdlclose
 LCC_RETURN wrapped_PERCENTdlclose_ForeignData_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTdlclose(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTdlopen
 LCC_RETURN wrapped_PERCENTdlopen_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTdlopen(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTforeign_data_pointerp
 LCC_RETURN wrapped_PERCENTforeign_data_pointerp_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTforeign_data_pointerp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTcore_pointer_from_foreign_data
 LCC_RETURN wrapped_PERCENTcore_pointer_from_foreign_data_ForeignData_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<clasp_ffi::ForeignData_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pointer_sp ret = clasp_ffi ::PERCENTcore_pointer_from_foreign_data(a0._v);
     return translate::to_object<core::Pointer_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENToffset_address_as_integer
 LCC_RETURN wrapped_PERCENToffset_address_as_integer_core__T_spcore__Integer_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = clasp_ffi ::PERCENToffset_address_as_integer(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTnull_pointer_p
 LCC_RETURN wrapped_PERCENTnull_pointer_p_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTnull_pointer_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmake_nullpointer
 LCC_RETURN wrapped_PERCENTmake_nullpointer_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    clasp_ffi::ForeignData_sp ret = clasp_ffi ::PERCENTmake_nullpointer();
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTpointerp
 LCC_RETURN wrapped_PERCENTpointerp_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = clasp_ffi ::PERCENTpointerp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTmake_pointer
 LCC_RETURN wrapped_PERCENTmake_pointer_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = clasp_ffi ::PERCENTmake_pointer(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTallocate_foreign_data
 LCC_RETURN wrapped_PERCENTallocate_foreign_data_core__Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = clasp_ffi ::PERCENTallocate_foreign_data(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for clasp_ffi::PERCENTallocate_foreign_object
 LCC_RETURN wrapped_PERCENTallocate_foreign_object_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    clasp_ffi::ForeignData_sp ret = clasp_ffi ::PERCENTallocate_foreign_object(a0._v);
     return translate::to_object<clasp_ffi::ForeignData_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__remove_equal
 LCC_RETURN wrapped_core__remove_equal_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__remove_equal(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nreconc
 LCC_RETURN wrapped_cl__nreconc_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__nreconc(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__revappend
 LCC_RETURN wrapped_cl__revappend_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__revappend(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nconc
 LCC_RETURN wrapped_cl__nconc_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__nconc(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__last
 LCC_RETURN wrapped_cl__last_List_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__last(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__listSTAR
 LCC_RETURN wrapped_cl__listSTAR_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__listSTAR(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__list
 LCC_RETURN wrapped_cl__list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__list(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nbutlast
 LCC_RETURN wrapped_cl__nbutlast_List_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::cl__nbutlast(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__butlast
 LCC_RETURN wrapped_cl__butlast_List_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::cl__butlast(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__copy_list
 LCC_RETURN wrapped_cl__copy_list_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__copy_list(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nthcdr
 LCC_RETURN wrapped_cl__nthcdr_Integer_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__nthcdr(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__nth
 LCC_RETURN wrapped_cl__nth_Integer_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__nth(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rassoc
 LCC_RETURN wrapped_cl__rassoc_T_spList_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::cl__rassoc(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::sys__spawn_subprocess
 LCC_RETURN wrapped_sys__spawn_subprocess_T_spT_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    auto ret = core ::sys__spawn_subprocess(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return ret.as_return_type();
    }
// Generating code for core::sys__killpid
 LCC_RETURN wrapped_sys__killpid_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::sys__killpid(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__waitpid
 LCC_RETURN wrapped_core__waitpid_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__waitpid(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__stat
 LCC_RETURN wrapped_ext__stat_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::ext__stat(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__fstat
 LCC_RETURN wrapped_ext__fstat_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::ext__fstat(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__getenv
 LCC_RETURN wrapped_ext__getenv_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::ext__getenv(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__fork_execvp
 LCC_RETURN wrapped_ext__fork_execvp_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::ext__fork_execvp(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__vfork_execvp
 LCC_RETURN wrapped_ext__vfork_execvp_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::ext__vfork_execvp(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__pipe
 LCC_RETURN wrapped_core__pipe_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    auto ret = core ::core__pipe();
     return ret.as_return_type();
    }
// Generating code for core::core__setpgrp
 LCC_RETURN wrapped_core__setpgrp_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = core ::core__setpgrp();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__setpgid
 LCC_RETURN wrapped_core__setpgid_pid_tpid_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<pid_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<pid_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = core ::core__setpgid(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::ext__system
 LCC_RETURN wrapped_ext__system_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::ext__system(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::ext__setenv
 LCC_RETURN wrapped_ext__setenv_String_spString_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::ext__setenv(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__ensure_directory
 LCC_RETURN wrapped_core__ensure_directory_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__ensure_directory(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mkdir
 LCC_RETURN wrapped_core__mkdir_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__mkdir(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__unix_get_local_time_zone
 LCC_RETURN wrapped_core__unix_get_local_time_zone_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Rational_sp ret = core ::core__unix_get_local_time_zone();
     return translate::to_object<core::Rational_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__unix_daylight_saving_time
 LCC_RETURN wrapped_core__unix_daylight_saving_time_Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__unix_daylight_saving_time(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__directory
 LCC_RETURN wrapped_cl__directory_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__directory(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__copy_file
 LCC_RETURN wrapped_core__copy_file_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__copy_file(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__chmod
 LCC_RETURN wrapped_core__chmod_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__chmod(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__rmdir
 LCC_RETURN wrapped_core__rmdir_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__rmdir(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mkdtemp
 LCC_RETURN wrapped_core__mkdtemp_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__mkdtemp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__rmtree
 LCC_RETURN wrapped_ext__rmtree_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::ext__rmtree(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__mkstemp_fd
 LCC_RETURN wrapped_core__mkstemp_fd_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__mkstemp_fd(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mkstemp
 LCC_RETURN wrapped_core__mkstemp_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__mkstemp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__temporary_directory
 LCC_RETURN wrapped_core__temporary_directory_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__temporary_directory();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__user_homedir_pathname
 LCC_RETURN wrapped_cl__user_homedir_pathname_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::cl__user_homedir_pathname(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_author
 LCC_RETURN wrapped_cl__file_author_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__file_author(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__file_write_date
 LCC_RETURN wrapped_cl__file_write_date_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__file_write_date(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__probe_file
 LCC_RETURN wrapped_cl__probe_file_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__probe_file(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__delete_file
 LCC_RETURN wrapped_cl__delete_file_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__delete_file(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rename_file
 LCC_RETURN wrapped_cl__rename_file_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::cl__rename_file(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__truename
 LCC_RETURN wrapped_cl__truename_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::cl__truename(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::gray__PERCENTtruename
 LCC_RETURN wrapped_gray__PERCENTtruename_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pathname_sp ret = core ::gray__PERCENTtruename(a0._v);
     return translate::to_object<core::Pathname_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__file_truename
 LCC_RETURN wrapped_core__file_truename_T_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__file_truename(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__readlink
 LCC_RETURN wrapped_core__readlink_String_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__readlink(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__file_kind
 LCC_RETURN wrapped_core__file_kind_T_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Symbol_sp ret = core ::core__file_kind(a0._v,a1._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for ext::ext__getcwd
 LCC_RETURN wrapped_ext__getcwd_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Str8Ns_sp ret = ext ::ext__getcwd();
     return translate::to_object<core::Str8Ns_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__chdir
 LCC_RETURN wrapped_ext__chdir_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::ext__chdir(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__getppid
 LCC_RETURN wrapped_core__getppid_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__getppid();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__getpid
 LCC_RETURN wrapped_core__getpid_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__getpid();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__wifsignaled
 LCC_RETURN wrapped_core__wifsignaled_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__wifsignaled(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__wtermsig
 LCC_RETURN wrapped_core__wtermsig_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = core ::core__wtermsig(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__wexitstatus
 LCC_RETURN wrapped_core__wexitstatus_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = core ::core__wexitstatus(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__wifexited
 LCC_RETURN wrapped_core__wifexited_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__wifexited(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__wait
 LCC_RETURN wrapped_core__wait_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    auto ret = core ::core__wait();
     return ret.as_return_type();
    }
// Generating code for core::core__fork_redirect
 LCC_RETURN wrapped_core__fork_redirect_intint (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__fork_redirect(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__fork
 LCC_RETURN wrapped_core__fork_bool (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<bool> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__fork(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__enum_logical_or
 LCC_RETURN wrapped_core__enum_logical_or_SymbolToEnumConverter_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SymbolToEnumConverter_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    Fixnum ret = core ::core__enum_logical_or(a0._v,a1._v);
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__makeSourcePosInfo
 LCC_RETURN wrapped_core__makeSourcePosInfo_const_string_boolsize_tboolsize_tboolsize_tboolT_spboolT_spboolT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8,core::T_O* in9,core::T_O* in10,core::T_O* in11,core::T_O* in12,core::T_O* in13) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<size_t> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<bool> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<size_t> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<bool> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<core::T_sp> a8 (core::T_sp((gc::Tagged)(in8)));
                     translate::from_object<bool> a9 (core::T_sp((gc::Tagged)(in9)));
                     translate::from_object<core::T_sp> a10 (core::T_sp((gc::Tagged)(in10)));
                     translate::from_object<bool> a11 (core::T_sp((gc::Tagged)(in11)));
                     translate::from_object<core::T_sp> a12 (core::T_sp((gc::Tagged)(in12)));
                     translate::from_object<bool> a13 (core::T_sp((gc::Tagged)(in13)));
                     
    core::SourcePosInfo_sp ret = core ::core__makeSourcePosInfo(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v,a9._v,a10._v,a11._v,a12._v,a13._v);
     return translate::to_object<core::SourcePosInfo_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_column
 LCC_RETURN wrapped_core__source_pos_info_column_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = core ::core__source_pos_info_column(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_lineno
 LCC_RETURN wrapped_core__source_pos_info_lineno_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = core ::core__source_pos_info_lineno(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_filepos
 LCC_RETURN wrapped_core__source_pos_info_filepos_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::core__source_pos_info_filepos(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_file_handle
 LCC_RETURN wrapped_core__source_pos_info_file_handle_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::core__source_pos_info_file_handle(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__source_pos_info_unpack
 LCC_RETURN wrapped_core__source_pos_info_unpack_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__source_pos_info_unpack(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__file_scope
 LCC_RETURN wrapped_core__file_scope_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__file_scope(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__print
 LCC_RETURN wrapped_cl__print_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__print(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__prin1
 LCC_RETURN wrapped_cl__prin1_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__prin1(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__princ
 LCC_RETURN wrapped_cl__princ_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__princ(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__pprint
 LCC_RETURN wrapped_cl__pprint_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::cl__pprint(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__write
 LCC_RETURN wrapped_cl__write_T_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7,core::T_O* in8,core::T_O* in9,core::T_O* in10,core::T_O* in11,core::T_O* in12,core::T_O* in13,core::T_O* in14,core::T_O* in15,core::T_O* in16) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::T_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<core::T_sp> a7 (core::T_sp((gc::Tagged)(in7)));
                     translate::from_object<core::T_sp> a8 (core::T_sp((gc::Tagged)(in8)));
                     translate::from_object<core::T_sp> a9 (core::T_sp((gc::Tagged)(in9)));
                     translate::from_object<core::T_sp> a10 (core::T_sp((gc::Tagged)(in10)));
                     translate::from_object<core::T_sp> a11 (core::T_sp((gc::Tagged)(in11)));
                     translate::from_object<core::T_sp> a12 (core::T_sp((gc::Tagged)(in12)));
                     translate::from_object<core::T_sp> a13 (core::T_sp((gc::Tagged)(in13)));
                     translate::from_object<core::T_sp> a14 (core::T_sp((gc::Tagged)(in14)));
                     translate::from_object<core::T_sp> a15 (core::T_sp((gc::Tagged)(in15)));
                     translate::from_object<core::T_sp> a16 (core::T_sp((gc::Tagged)(in16)));
                     
    core::T_sp ret = core ::cl__write(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v,a8._v,a9._v,a10._v,a11._v,a12._v,a13._v,a14._v,a15._v,a16._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__write_dense_specialized_array
 LCC_RETURN wrapped_core__write_dense_specialized_array_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__write_dense_specialized_array(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__write_object
 LCC_RETURN wrapped_core__write_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__write_object(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__bignum_do_fixnum_add_over
 LCC_RETURN wrapped_core__bignum_do_fixnum_add_over_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Bignum_sp ret = core ::core__bignum_do_fixnum_add_over(a0._v,a1._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__bignum_from_fixnum_add_over
 LCC_RETURN wrapped_core__bignum_from_fixnum_add_over_int64_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int64_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Bignum_sp ret = core ::core__bignum_from_fixnum_add_over(a0._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__dump_bignum
 LCC_RETURN wrapped_core__dump_bignum_Bignum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Bignum_sp ret = core ::core__dump_bignum(a0._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_compare
 LCC_RETURN wrapped_core__next_compare_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    int ret = core ::core__next_compare(a0._v,a1._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::sub_xb
 LCC_RETURN wrapped_Number_O__sub_xb_FixnumBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::Number_O::sub_xb(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::add_bx
 LCC_RETURN wrapped_Number_O__add_bx_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::Number_O::add_bx(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::sub_bb
 LCC_RETURN wrapped_Number_O__sub_bb_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::Number_O::sub_bb(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::add_bb
 LCC_RETURN wrapped_Number_O__add_bb_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::Number_O::add_bb(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_fgcd
 LCC_RETURN wrapped_core__next_fgcd_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__next_fgcd(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_gcd
 LCC_RETURN wrapped_core__next_gcd_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__next_gcd(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_ftruncate
 LCC_RETURN wrapped_core__next_ftruncate_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__next_ftruncate(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__next_truncate
 LCC_RETURN wrapped_core__next_truncate_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__next_truncate(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__mul_fixnums
 LCC_RETURN wrapped_core__mul_fixnums_FixnumFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Bignum_sp ret = core ::core__mul_fixnums(a0._v,a1._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::mul_bb
 LCC_RETURN wrapped_Number_O__mul_bb_Bignum_spBignum_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Bignum_sp ret = core ::Number_O::mul_bb(a0._v,a1._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_rshift
 LCC_RETURN wrapped_core__next_rshift_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__next_rshift(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_lshift
 LCC_RETURN wrapped_core__next_lshift_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Bignum_sp ret = core ::core__next_lshift(a0._v,a1._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::mul_bx
 LCC_RETURN wrapped_Number_O__mul_bx_Bignum_spFixnum (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::Number_O::mul_bx(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_primitive_string
 LCC_RETURN wrapped_core__next_primitive_string_Bignum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Bignum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    string ret = core ::core__next_primitive_string(a0._v);
     return translate::to_object<string>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_from_string
 LCC_RETURN wrapped_core__next_from_string_const_string_ (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Bignum_sp ret = core ::core__next_from_string(a0._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_from_fixnum
 LCC_RETURN wrapped_core__next_from_fixnum_Fixnum (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Bignum_sp ret = core ::core__next_from_fixnum(a0._v);
     return translate::to_object<core::Bignum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__load
 LCC_RETURN wrapped_cl__load_T_spT_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::cl__load(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__load_no_package_set
 LCC_RETURN wrapped_core__load_no_package_set_T_spT_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     
    core::T_sp ret = core ::core__load_no_package_set(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__load_source
 LCC_RETURN wrapped_core__load_source_T_spboolboolcore__T_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::core__load_source(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__imagpart
 LCC_RETURN wrapped_cl__imagpart_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Real_sp ret = core ::cl__imagpart(a0._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__realpart
 LCC_RETURN wrapped_cl__realpart_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Real_sp ret = core ::cl__realpart(a0._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__complex
 LCC_RETURN wrapped_cl__complex_Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Complex_sp ret = core ::cl__complex(a0._v,a1._v);
     return translate::to_object<core::Complex_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__integer_decode_float
 LCC_RETURN wrapped_cl__integer_decode_float_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__integer_decode_float(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__float_precision
 LCC_RETURN wrapped_cl__float_precision_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__float_precision(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__float_digits
 LCC_RETURN wrapped_cl__float_digits_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__float_digits(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__float_sign
 LCC_RETURN wrapped_cl__float_sign_Float_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Float_sp ret = core ::cl__float_sign(a0._v,a1._v,a2._v);
     return translate::to_object<core::Float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__scale_float
 LCC_RETURN wrapped_cl__scale_float_Number_spFixnum (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::cl__scale_float(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__decode_float
 LCC_RETURN wrapped_cl__decode_float_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__decode_float(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__rem
 LCC_RETURN wrapped_cl__rem_Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Real_sp ret = core ::cl__rem(a0._v,a1._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mod
 LCC_RETURN wrapped_cl__mod_Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Real_sp ret = core ::cl__mod(a0._v,a1._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__round
 LCC_RETURN wrapped_cl__round_Real_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__round(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__truncate
 LCC_RETURN wrapped_cl__truncate_Real_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__truncate(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__ceiling
 LCC_RETURN wrapped_cl__ceiling_Real_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__ceiling(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__floor
 LCC_RETURN wrapped_cl__floor_Real_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__floor(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__denominator
 LCC_RETURN wrapped_cl__denominator_Rational_sp (core::T_O* in0) {
    
    translate::from_object<core::Rational_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__denominator(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__numerator
 LCC_RETURN wrapped_cl__numerator_Rational_sp (core::T_O* in0) {
    
    translate::from_object<core::Rational_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__numerator(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__to_long_float
 LCC_RETURN wrapped_core__to_long_float_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::LongFloat_sp ret = core ::core__to_long_float(a0._v);
     return translate::to_object<core::LongFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__to_double_float
 LCC_RETURN wrapped_core__to_double_float_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::DoubleFloat_sp ret = core ::core__to_double_float(a0._v);
     return translate::to_object<core::DoubleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__to_single_float
 LCC_RETURN wrapped_core__to_single_float_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SingleFloat_sp ret = core ::core__to_single_float(a0._v);
     return translate::to_object<core::SingleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__float
 LCC_RETURN wrapped_cl__float_Real_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Float_sp ret = core ::cl__float(a0._v,a1._v,a2._v);
     return translate::to_object<core::Float_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__integer_to_string
 LCC_RETURN wrapped_core__integer_to_string_StrNs_spInteger_spFixnum_spboolbool (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::StrNs_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<bool> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::StrNs_sp ret = core ::core__integer_to_string(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::StrNs_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_to_string
 LCC_RETURN wrapped_core__next_to_string_StrNs_spBignum_spFixnum_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::StrNs_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Bignum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Fixnum_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::StrNs_sp ret = core ::core__next_to_string(a0._v,a1._v,a2._v);
     return translate::to_object<core::StrNs_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lcm
 LCC_RETURN wrapped_cl__lcm_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__lcm(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__gcd
 LCC_RETURN wrapped_cl__gcd_List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::cl__gcd(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__num_op_atanh
 LCC_RETURN wrapped_core__num_op_atanh_double (core::T_O* in0) {
    
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::core__num_op_atanh(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::core__num_op_acosh
 LCC_RETURN wrapped_core__num_op_acosh_double (core::T_O* in0) {
    
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::core__num_op_acosh(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::core__num_op_asinh
 LCC_RETURN wrapped_core__num_op_asinh_double (core::T_O* in0) {
    
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::core__num_op_asinh(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::core__num_op_acos
 LCC_RETURN wrapped_core__num_op_acos_double (core::T_O* in0) {
    
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::core__num_op_acos(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::core__num_op_asin
 LCC_RETURN wrapped_core__num_op_asin_double (core::T_O* in0) {
    
    translate::from_object<double> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::core__num_op_asin(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::cl__get_universal_time
 LCC_RETURN wrapped_cl__get_universal_time_ () {
    
    
    core::Integer_sp ret = core ::cl__get_universal_time();
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__positive_integer_to_mixed_base_digits
 LCC_RETURN wrapped_core__positive_integer_to_mixed_base_digits_core__Integer_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__positive_integer_to_mixed_base_digits(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rationalize
 LCC_RETURN wrapped_cl__rationalize_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Rational_sp ret = core ::cl__rationalize(a0._v);
     return translate::to_object<core::Rational_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rational
 LCC_RETURN wrapped_cl__rational_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Rational_sp ret = core ::cl__rational(a0._v);
     return translate::to_object<core::Rational_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__bits_to_long_float
 LCC_RETURN wrapped_ext__bits_to_long_float_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::LongFloat_sp ret = core ::ext__bits_to_long_float(a0._v);
     return translate::to_object<core::LongFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__long_float_to_bits
 LCC_RETURN wrapped_ext__long_float_to_bits_LongFloat_sp (core::T_O* in0) {
    
    translate::from_object<core::LongFloat_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::ext__long_float_to_bits(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__bits_to_double_float
 LCC_RETURN wrapped_ext__bits_to_double_float_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::DoubleFloat_sp ret = core ::ext__bits_to_double_float(a0._v);
     return translate::to_object<core::DoubleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__double_float_to_bits
 LCC_RETURN wrapped_ext__double_float_to_bits_DoubleFloat_sp (core::T_O* in0) {
    
    translate::from_object<core::DoubleFloat_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::ext__double_float_to_bits(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__bits_to_single_float
 LCC_RETURN wrapped_ext__bits_to_single_float_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SingleFloat_sp ret = core ::ext__bits_to_single_float(a0._v);
     return translate::to_object<core::SingleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__single_float_to_bits
 LCC_RETURN wrapped_ext__single_float_to_bits_SingleFloat_sp (core::T_O* in0) {
    
    translate::from_object<core::SingleFloat_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Integer_sp ret = core ::ext__single_float_to_bits(a0._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__float_infinity_p
 LCC_RETURN wrapped_ext__float_infinity_p_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__float_infinity_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::ext__float_nan_p
 LCC_RETURN wrapped_ext__float_nan_p_Float_sp (core::T_O* in0) {
    
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__float_nan_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__logcount
 LCC_RETURN wrapped_cl__logcount_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gc::Fixnum ret = core ::cl__logcount(a0._v);
     return translate::to_object<gc::Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::cl__integer_length
 LCC_RETURN wrapped_cl__integer_length_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gc::Fixnum ret = core ::cl__integer_length(a0._v);
     return translate::to_object<gc::Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__log1p
 LCC_RETURN wrapped_core__log1p_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::core__log1p(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__log
 LCC_RETURN wrapped_cl__log_Number_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::cl__log(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__atan
 LCC_RETURN wrapped_cl__atan_Number_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Number_sp ret = core ::cl__atan(a0._v,a1._v,a2._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__expt
 LCC_RETURN wrapped_cl__expt_Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::cl__expt(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__exp
 LCC_RETURN wrapped_cl__exp_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__exp(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__conjugate
 LCC_RETURN wrapped_cl__conjugate_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__conjugate(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__tanh
 LCC_RETURN wrapped_cl__tanh_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__tanh(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__cosh
 LCC_RETURN wrapped_cl__cosh_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__cosh(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__sinh
 LCC_RETURN wrapped_cl__sinh_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__sinh(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__tan
 LCC_RETURN wrapped_cl__tan_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__tan(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__cos
 LCC_RETURN wrapped_cl__cos_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__cos(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__acos
 LCC_RETURN wrapped_cl__acos_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__acos(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__asin
 LCC_RETURN wrapped_cl__asin_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__asin(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__sin
 LCC_RETURN wrapped_cl__sin_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__sin(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__abs
 LCC_RETURN wrapped_cl__abs_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__abs(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__sqrt
 LCC_RETURN wrapped_cl__sqrt_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__sqrt(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__signum
 LCC_RETURN wrapped_cl__signum_Number_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__signum(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__nan
 LCC_RETURN wrapped_core__nan_ () {
    
    
    core::DoubleFloat_sp ret = core ::core__nan();
     return translate::to_object<core::DoubleFloat_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___EQ_
 LCC_RETURN wrapped_cl___EQ__List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___EQ_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___NE_
 LCC_RETURN wrapped_cl___NE__Vaslist_sp (core::T_O* in0) {
    
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___NE_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__EQ_
 LCC_RETURN wrapped_two_arg__EQ__Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::two_arg__EQ_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl___GE_
 LCC_RETURN wrapped_cl___GE__Vaslist_sp (core::T_O* in0) {
    
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___GE_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___LE_
 LCC_RETURN wrapped_cl___LE__Vaslist_sp (core::T_O* in0) {
    
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___LE_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___GT_
 LCC_RETURN wrapped_cl___GT__Vaslist_sp (core::T_O* in0) {
    
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___GT_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___LT_
 LCC_RETURN wrapped_cl___LT__Vaslist_sp (core::T_O* in0) {
    
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl___LT_(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__GE_
 LCC_RETURN wrapped_two_arg__GE__Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::two_arg__GE_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__GT_
 LCC_RETURN wrapped_two_arg__GT__Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::two_arg__GT_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__LE_
 LCC_RETURN wrapped_two_arg__LE__Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::two_arg__LE_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__LT_
 LCC_RETURN wrapped_two_arg__LT__Real_spReal_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Real_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::two_arg__LT_(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl___DIVIDE_
 LCC_RETURN wrapped_cl___DIVIDE__Number_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::cl___DIVIDE_(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___MINUS_
 LCC_RETURN wrapped_cl___MINUS__Number_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::cl___MINUS_(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___TIMES_
 LCC_RETURN wrapped_cl___TIMES__List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl___TIMES_(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl___PLUS_
 LCC_RETURN wrapped_cl___PLUS__List_sp (core::T_O* in0) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl___PLUS_(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::div_nn
 LCC_RETURN wrapped_Number_O__div_nn_Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::Number_O::div_nn(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::mul_nn
 LCC_RETURN wrapped_Number_O__mul_nn_Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::Number_O::mul_nn(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::sub_nn
 LCC_RETURN wrapped_Number_O__sub_nn_Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::Number_O::sub_nn(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::Number_O::add_nn
 LCC_RETURN wrapped_Number_O__add_nn_Number_spNumber_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Number_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::Number_O::add_nn(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::two_arg__PLUS_FF
 LCC_RETURN wrapped_two_arg__PLUS_FF_FixnumFixnum (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<Fixnum> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<Fixnum> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Number_sp ret = core ::two_arg__PLUS_FF(a0._v,a1._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__max
 LCC_RETURN wrapped_cl__max_Real_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Real_sp ret = core ::cl__max(a0._v,a1._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__min
 LCC_RETURN wrapped_cl__min_Real_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Real_sp ret = core ::cl__min(a0._v,a1._v);
     return translate::to_object<core::Real_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fixnum_number_of_bits
 LCC_RETURN wrapped_core__fixnum_number_of_bits_ () {
    
    
    core::Fixnum_sp ret = core ::core__fixnum_number_of_bits();
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__oddp
 LCC_RETURN wrapped_cl__oddp_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__oddp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__evenp
 LCC_RETURN wrapped_cl__evenp_Integer_sp (core::T_O* in0) {
    
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__evenp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__plusp
 LCC_RETURN wrapped_cl__plusp_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__plusp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__minusp
 LCC_RETURN wrapped_cl__minusp_Real_sp (core::T_O* in0) {
    
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__minusp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__zerop
 LCC_RETURN wrapped_cl__zerop_Number_sp (core::T_O* in0) {
    
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__zerop(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__hash_table_test
 LCC_RETURN wrapped_cl__hash_table_test_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__hash_table_test(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__hash_table_rehash_threshold
 LCC_RETURN wrapped_cl__hash_table_rehash_threshold_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    double ret = core ::cl__hash_table_rehash_threshold(a0._v);
     return translate::to_object<double>::convert(ret).as_return_type();
    }
// Generating code for core::cl__hash_table_rehash_size
 LCC_RETURN wrapped_cl__hash_table_rehash_size_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::cl__hash_table_rehash_size(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash_table_force_rehash
 LCC_RETURN wrapped_core__hash_table_force_rehash_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__hash_table_force_rehash(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__gethash3
 LCC_RETURN wrapped_core__gethash3_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__gethash3(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__gethash
 LCC_RETURN wrapped_cl__gethash_T_spHashTable_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::HashTable_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::cl__gethash(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__hash_table_size
 LCC_RETURN wrapped_cl__hash_table_size_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    uint ret = core ::cl__hash_table_size(a0._v);
     return translate::to_object<uint>::convert(ret).as_return_type();
    }
// Generating code for core::cl__hash_table_count
 LCC_RETURN wrapped_cl__hash_table_count_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::cl__hash_table_count(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::cl__remhash
 LCC_RETURN wrapped_cl__remhash_T_spHashTable_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::HashTable_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__remhash(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash_equalp
 LCC_RETURN wrapped_core__hash_equalp_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    Fixnum ret = core ::core__hash_equalp(a0._v);
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash_equal
 LCC_RETURN wrapped_core__hash_equal_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    Fixnum ret = core ::core__hash_equal(a0._v);
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::cl__clrhash
 LCC_RETURN wrapped_cl__clrhash_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__clrhash(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__maphash
 LCC_RETURN wrapped_cl__maphash_T_spHashTable_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::HashTable_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__maphash(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash_table_weakness
 LCC_RETURN wrapped_core__hash_table_weakness_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::core__hash_table_weakness(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__make_hash_table
 LCC_RETURN wrapped_cl__make_hash_table_T_spFixnum_spNumber_spReal_spSymbol_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Number_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Real_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::Symbol_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::T_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<core::T_sp> a7 (core::T_sp((gc::Tagged)(in7)));
                     
    core::T_sp ret = core ::cl__make_hash_table(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash_table_pairs
 LCC_RETURN wrapped_core__hash_table_pairs_HashTable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::HashTable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Vector_sp ret = core ::core__hash_table_pairs(a0._v);
     return translate::to_object<core::Vector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_small_multimap
 LCC_RETURN wrapped_core__make_small_multimap_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::SmallMultimap_sp ret = core ::core__make_small_multimap();
     return translate::to_object<core::SmallMultimap_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_small_map
 LCC_RETURN wrapped_core__make_small_map_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::SmallMap_sp ret = core ::core__make_small_map();
     return translate::to_object<core::SmallMap_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__walk_loaded_objects
 LCC_RETURN wrapped_core__walk_loaded_objects_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__walk_loaded_objects();
     return Values0<core::T_O>();
    }
// Generating code for core::core__link_fasl_files
 LCC_RETURN wrapped_core__link_fasl_files_T_spT_spbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__link_fasl_files(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::load_bytecode
 LCC_RETURN wrapped_load_bytecode_T_spboolboolT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    bool ret = core ::load_bytecode(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::load_bytecode_stream
 LCC_RETURN wrapped_load_bytecode_stream_Stream_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Stream_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::load_bytecode_stream(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::bytecode_toplevel_eval
 LCC_RETURN wrapped_bytecode_toplevel_eval_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = comp ::bytecode_toplevel_eval(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecode_toplevel_symbol_macrolet
 LCC_RETURN wrapped_bytecode_toplevel_symbol_macrolet_List_spList_spLexenv_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::Lexenv_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = comp ::bytecode_toplevel_symbol_macrolet(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecode_toplevel_macrolet
 LCC_RETURN wrapped_bytecode_toplevel_macrolet_List_spList_spLexenv_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::Lexenv_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = comp ::bytecode_toplevel_macrolet(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecode_toplevel_locally
 LCC_RETURN wrapped_bytecode_toplevel_locally_List_spLexenv_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::Lexenv_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = comp ::bytecode_toplevel_locally(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecode_toplevel_eval_when
 LCC_RETURN wrapped_bytecode_toplevel_eval_when_List_spList_spLexenv_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::Lexenv_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = comp ::bytecode_toplevel_eval_when(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecode_toplevel_progn
 LCC_RETURN wrapped_bytecode_toplevel_progn_List_spLexenv_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::Lexenv_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = comp ::bytecode_toplevel_progn(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for comp::cmp__bytecode_implicit_compile_form
 LCC_RETURN wrapped_cmp__bytecode_implicit_compile_form_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = comp ::cmp__bytecode_implicit_compile_form(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for comp::bytecompile
 LCC_RETURN wrapped_bytecompile_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp::Function_sp ret = comp ::bytecompile(a0._v,a1._v);
     return translate::to_object<comp::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::bytecompile_into
 LCC_RETURN wrapped_bytecompile_into_Module_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::Module_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    comp::Cfunction_sp ret = comp ::bytecompile_into(a0._v,a1._v,a2._v);
     return translate::to_object<comp::Cfunction_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::compile_lambda
 LCC_RETURN wrapped_compile_lambda_T_spList_spLexenv_spModule_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::Lexenv_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<comp::Module_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<comp::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    comp::Cfunction_sp ret = comp ::compile_lambda(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<comp::Cfunction_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::cmp__malformed_binding
 LCC_RETURN wrapped_cmp__malformed_binding_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    comp ::cmp__malformed_binding(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::cmp__warn_set_unused_variable
 LCC_RETURN wrapped_cmp__warn_set_unused_variable_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp ::cmp__warn_set_unused_variable(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::cmp__warn_unused_variable
 LCC_RETURN wrapped_cmp__warn_unused_variable_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp ::cmp__warn_unused_variable(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::cmp__warn_used_ignored_variable
 LCC_RETURN wrapped_cmp__warn_used_ignored_variable_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp ::cmp__warn_used_ignored_variable(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::cmp__expand_compiler_macro_safely
 LCC_RETURN wrapped_cmp__expand_compiler_macro_safely_Function_spT_spLexenv_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::Lexenv_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<comp::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    comp::T_sp ret = comp ::cmp__expand_compiler_macro_safely(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<comp::T_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::lambda_list_for_name
 LCC_RETURN wrapped_lambda_list_for_name_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    comp::T_sp ret = comp ::lambda_list_for_name(a0._v);
     return translate::to_object<comp::T_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::cmp__fun_info
 LCC_RETURN wrapped_cmp__fun_info_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp::T_sp ret = comp ::cmp__fun_info(a0._v,a1._v);
     return translate::to_object<comp::T_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::cmp__var_info
 LCC_RETURN wrapped_cmp__var_info_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<comp::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    comp::T_sp ret = comp ::cmp__var_info(a0._v,a1._v);
     return translate::to_object<comp::T_sp>::convert(ret).as_return_type();
    }
// Generating code for comp::assemble_into
 LCC_RETURN wrapped_assemble_into_SimpleVector_byte8_t_spsize_tList_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::SimpleVector_byte8_t_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<comp::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    comp ::assemble_into(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for comp::make_null_lexical_environment
 LCC_RETURN wrapped_make_null_lexical_environment_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<comp::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    comp::Lexenv_sp ret = comp ::make_null_lexical_environment(a0._v);
     return translate::to_object<comp::Lexenv_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__map_bytecode_modules
 LCC_RETURN wrapped_core__map_bytecode_modules_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__map_bytecode_modules(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__side_stack_pointer
 LCC_RETURN wrapped_core__side_stack_pointer_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Integer_sp ret = core ::core__side_stack_pointer();
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_local_declline
 LCC_RETURN wrapped_core__debugger_local_declline_DebuggerLocal_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerLocal_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_local_declline(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_local_declfile
 LCC_RETURN wrapped_core__debugger_local_declfile_DebuggerLocal_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerLocal_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_local_declfile(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_local_name
 LCC_RETURN wrapped_core__debugger_local_name_DebuggerLocal_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerLocal_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_local_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_local_fname
 LCC_RETURN wrapped_core__debugger_local_fname_DebuggerLocal_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerLocal_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_local_fname(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_down
 LCC_RETURN wrapped_core__debugger_frame_down_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_down(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_up
 LCC_RETURN wrapped_core__debugger_frame_up_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_up(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_xep_p
 LCC_RETURN wrapped_core__debugger_frame_xep_p_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__debugger_frame_xep_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_args_available_p
 LCC_RETURN wrapped_core__debugger_frame_args_available_p_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__debugger_frame_args_available_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_args
 LCC_RETURN wrapped_core__debugger_frame_args_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_args(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_closure
 LCC_RETURN wrapped_core__debugger_frame_closure_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_closure(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_locals
 LCC_RETURN wrapped_core__debugger_frame_locals_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__debugger_frame_locals(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_lang
 LCC_RETURN wrapped_core__debugger_frame_lang_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_lang(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_function_description
 LCC_RETURN wrapped_core__debugger_frame_function_description_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_function_description(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_source_position
 LCC_RETURN wrapped_core__debugger_frame_source_position_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_source_position(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__debugger_frame_fname
 LCC_RETURN wrapped_core__debugger_frame_fname_DebuggerFrame_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::DebuggerFrame_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__debugger_frame_fname(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__call_with_frame
 LCC_RETURN wrapped_core__call_with_frame_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__call_with_frame(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__sanity_check_backtrace
 LCC_RETURN wrapped_core__sanity_check_backtrace_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    bool ret = core ::core__sanity_check_backtrace();
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__early_debug
 LCC_RETURN wrapped_core__early_debug_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__early_debug(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__objectAddress
 LCC_RETURN wrapped_core__objectAddress_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pointer_sp ret = core ::core__objectAddress(a0._v);
     return translate::to_object<core::Pointer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__safe_repr
 LCC_RETURN wrapped_core__safe_repr_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    std::string ret = core ::core__safe_repr(a0._v);
     return translate::to_object<std::string>::convert(ret).as_return_type();
    }
// Generating code for core::core__lookup_address
 LCC_RETURN wrapped_core__lookup_address_core__Pointer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__lookup_address(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__lowLevelDescribe
 LCC_RETURN wrapped_core__lowLevelDescribe_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__lowLevelDescribe(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__openDynamicLibraries
 LCC_RETURN wrapped_core__openDynamicLibraries_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__openDynamicLibraries();
     return Values0<core::T_O>();
    }
// Generating code for core::core__list_from_vaslist
 LCC_RETURN wrapped_core__list_from_vaslist_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__list_from_vaslist(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__vaslistp
 LCC_RETURN wrapped_core__vaslistp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__vaslistp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__vaslist_pop
 LCC_RETURN wrapped_core__vaslist_pop_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__vaslist_pop(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__vaslist_length
 LCC_RETURN wrapped_core__vaslist_length_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__vaslist_length(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__patch_object
 LCC_RETURN wrapped_core__patch_object_General_spRecord_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::General_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Record_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__patch_object(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__make_record_patcher
 LCC_RETURN wrapped_core__make_record_patcher_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Record_sp ret = core ::core__make_record_patcher(a0._v);
     return translate::to_object<core::Record_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_seeded_random_state
 LCC_RETURN wrapped_core__make_seeded_random_state_Integer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::RandomState_sp ret = core ::core__make_seeded_random_state(a0._v);
     return translate::to_object<core::RandomState_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__random
 LCC_RETURN wrapped_cl__random_Number_spRandomState_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::RandomState_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__random(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::RandomState_O::make
 LCC_RETURN wrapped_RandomState_O__make_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::RandomState_sp ret = core ::RandomState_O::make(a0._v);
     return translate::to_object<core::RandomState_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__tak
 LCC_RETURN wrapped_core__tak_intintintboolint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core ::core__tak(a0._v,a1._v,a2._v,a3._v,a4._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__ctak
 LCC_RETURN wrapped_core__ctak_intintintboolint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<bool> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<int> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core ::core__ctak(a0._v,a1._v,a2._v,a3._v,a4._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__countLinesInFile
 LCC_RETURN wrapped_core__countLinesInFile_const_std__string_size_tbool (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<bool> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__countLinesInFile(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__test_write_stream
 LCC_RETURN wrapped_core__test_write_stream_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__test_write_stream();
     return Values0<core::T_O>();
    }
// Generating code for core::core__character_string_that_fits_in_base_string_to_octets
 LCC_RETURN wrapped_core__character_string_that_fits_in_base_string_to_octets_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleVector_byte8_t_sp ret = core ::core__character_string_that_fits_in_base_string_to_octets(a0._v);
     return translate::to_object<core::SimpleVector_byte8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__base_string_to_octets
 LCC_RETURN wrapped_core__base_string_to_octets_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleVector_byte8_t_sp ret = core ::core__base_string_to_octets(a0._v);
     return translate::to_object<core::SimpleVector_byte8_t_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__digest_sha256
 LCC_RETURN wrapped_core__digest_sha256_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__digest_sha256(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__digest_md5
 LCC_RETURN wrapped_core__digest_md5_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__digest_md5(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__digest_sha1
 LCC_RETURN wrapped_core__digest_sha1_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__digest_sha1(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__hmac_sha256
 LCC_RETURN wrapped_core__hmac_sha256_SimpleVector_byte8_t_spSimpleVector_byte8_t_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleVector_byte8_t_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleVector_byte8_t_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__hmac_sha256(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__hash256_hex_string
 LCC_RETURN wrapped_core__hash256_hex_string_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__hash256_hex_string(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__variable_source_info
 LCC_RETURN wrapped_core__variable_source_info_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__variable_source_info(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_source_pos_info
 LCC_RETURN wrapped_core__function_source_pos_info_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__function_source_pos_info(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::ext__function_lambda_list
 LCC_RETURN wrapped_ext__function_lambda_list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::ext__function_lambda_list(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__sxhash
 LCC_RETURN wrapped_cl__sxhash_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = core ::cl__sxhash(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__type_of
 LCC_RETURN wrapped_cl__type_of_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__type_of(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__type_to_symbol
 LCC_RETURN wrapped_core__type_to_symbol_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__type_to_symbol(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__gensym
 LCC_RETURN wrapped_cl__gensym_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::cl__gensym(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__gensym_quick_char
 LCC_RETURN wrapped_core__gensym_quick_char_SimpleCharacterString_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleCharacterString_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Symbol_sp ret = core ::core__gensym_quick_char(a0._v,a1._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__gensym_quick
 LCC_RETURN wrapped_core__gensym_quick_SimpleBaseString_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleBaseString_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Symbol_sp ret = core ::core__gensym_quick(a0._v,a1._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sequence_start_end
 LCC_RETURN wrapped_core__sequence_start_end_T_spFixnum_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Fixnum_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__sequence_start_end(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__append
 LCC_RETURN wrapped_cl__append_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__append(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mapcan
 LCC_RETURN wrapped_cl__mapcan_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__mapcan(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mapcon
 LCC_RETURN wrapped_cl__mapcon_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__mapcon(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mapl
 LCC_RETURN wrapped_cl__mapl_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__mapl(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__maplist
 LCC_RETURN wrapped_cl__maplist_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__maplist(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mapc
 LCC_RETURN wrapped_cl__mapc_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__mapc(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__mapcar
 LCC_RETURN wrapped_cl__mapcar_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__mapcar(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__notany_list
 LCC_RETURN wrapped_core__notany_list_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__notany_list(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__some_list
 LCC_RETURN wrapped_core__some_list_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__some_list(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__every_list
 LCC_RETURN wrapped_core__every_list_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__every_list(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read_preserving_whitespace
 LCC_RETURN wrapped_cl__read_preserving_whitespace_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__read_preserving_whitespace(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fast_read
 LCC_RETURN wrapped_core__fast_read_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__fast_read(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read
 LCC_RETURN wrapped_cl__read_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::cl__read(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__read_with_native_reader
 LCC_RETURN wrapped_core__read_with_native_reader_T_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__read_with_native_reader(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__read_delimited_list
 LCC_RETURN wrapped_cl__read_delimited_list_Character_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::List_sp ret = core ::cl__read_delimited_list(a0._v,a1._v,a2._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__fmakunbound
 LCC_RETURN wrapped_cl__fmakunbound_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__fmakunbound(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__fboundp
 LCC_RETURN wrapped_cl__fboundp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__fboundp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_cell
 LCC_RETURN wrapped_core__function_cell_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__function_cell(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__ensure_function_cell
 LCC_RETURN wrapped_core__ensure_function_cell_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::FunctionCell_sp ret = core ::core__ensure_function_cell(a0._v);
     return translate::to_object<core::FunctionCell_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__fdefinition
 LCC_RETURN wrapped_cl__fdefinition_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__fdefinition(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fset
 LCC_RETURN wrapped_core__fset_T_spFunction_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::core__fset(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__class_of
 LCC_RETURN wrapped_cl__class_of_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Instance_sp ret = core ::cl__class_of(a0._v);
     return translate::to_object<core::Instance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__null
 LCC_RETURN wrapped_cl__null_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__null(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__identity
 LCC_RETURN wrapped_cl__identity_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__identity(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__constantp
 LCC_RETURN wrapped_cl__constantp_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__constantp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__symbol_constantp
 LCC_RETURN wrapped_core__symbol_constantp_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__symbol_constantp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__gdb_inspect
 LCC_RETURN wrapped_core__gdb_inspect_String_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::String_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__gdb_inspect(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__trap_execution
 LCC_RETURN wrapped_core__trap_execution_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__trap_execution(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__gdb
 LCC_RETURN wrapped_core__gdb_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__gdb(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__break_low_level
 LCC_RETURN wrapped_core__break_low_level_T_spList_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__break_low_level(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__ash
 LCC_RETURN wrapped_cl__ash_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::cl__ash(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__ash_right
 LCC_RETURN wrapped_core__ash_right_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__ash_right(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__ash_left
 LCC_RETURN wrapped_core__ash_left_Integer_spInteger_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Integer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Integer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Integer_sp ret = core ::core__ash_left(a0._v,a1._v);
     return translate::to_object<core::Integer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__special_operator_p
 LCC_RETURN wrapped_cl__special_operator_p_Symbol_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__special_operator_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__macro_function
 LCC_RETURN wrapped_cl__macro_function_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__macro_function(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_type
 LCC_RETURN wrapped_core__function_type_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__function_type(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_global_inline_status
 LCC_RETURN wrapped_core__setf_global_inline_status_core__T_spboolcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__setf_global_inline_status(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__get_global_inline_status
 LCC_RETURN wrapped_core__get_global_inline_status_core__T_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__get_global_inline_status(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__separate_pair_list
 LCC_RETURN wrapped_core__separate_pair_list_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__separate_pair_list(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__valid_function_name_p
 LCC_RETURN wrapped_core__valid_function_name_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__valid_function_name_p(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_block_name
 LCC_RETURN wrapped_core__function_block_name_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Symbol_sp ret = core ::core__function_block_name(a0._v);
     return translate::to_object<core::Symbol_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__values_list
 LCC_RETURN wrapped_cl__values_list_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__values_list(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__values
 LCC_RETURN wrapped_cl__values_Vaslist_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Vaslist_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__values(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__unbound
 LCC_RETURN wrapped_core__unbound_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__unbound();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__is_true
 LCC_RETURN wrapped_core__is_true_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__is_true(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__describe_cxx_object
 LCC_RETURN wrapped_core__describe_cxx_object_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__describe_cxx_object(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::ext__llvm_version
 LCC_RETURN wrapped_ext__llvm_version_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    auto ret = core ::ext__llvm_version();
     return ret.as_return_type();
    }
// Generating code for core::core__dump_tagged_fixnum
 LCC_RETURN wrapped_core__dump_tagged_fixnum_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__dump_tagged_fixnum(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__from_tagged_fixnum
 LCC_RETURN wrapped_core__from_tagged_fixnum_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    gctools::Fixnum ret = core ::core__from_tagged_fixnum(a0._v);
     return translate::to_object<gctools::Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__to_tagged_fixnum
 LCC_RETURN wrapped_core__to_tagged_fixnum_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__to_tagged_fixnum(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__all_registered_class_names
 LCC_RETURN wrapped_core__all_registered_class_names_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::Vector_sp ret = core ::core__all_registered_class_names();
     return translate::to_object<core::Vector_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__incomplete_next_higher_power_of_2
 LCC_RETURN wrapped_core__incomplete_next_higher_power_of_2_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = core ::core__incomplete_next_higher_power_of_2(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__print_address_of
 LCC_RETURN wrapped_core__print_address_of_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__print_address_of(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set
 LCC_RETURN wrapped_cl__set_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__set(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__argv
 LCC_RETURN wrapped_core__argv_int (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleBaseString_sp ret = core ::core__argv(a0._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__argc
 LCC_RETURN wrapped_core__argc_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = core ::core__argc();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::cl__machine_instance
 LCC_RETURN wrapped_cl__machine_instance_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__machine_instance();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__machine_version
 LCC_RETURN wrapped_cl__machine_version_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__machine_version();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__machine_type
 LCC_RETURN wrapped_cl__machine_type_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__machine_type();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__software_version
 LCC_RETURN wrapped_cl__software_version_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__software_version();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__software_type
 LCC_RETURN wrapped_cl__software_type_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__software_type();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__value_from_tagged_immediate
 LCC_RETURN wrapped_core__value_from_tagged_immediate_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__value_from_tagged_immediate(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__create_tagged_immediate_value_or_nil
 LCC_RETURN wrapped_core__create_tagged_immediate_value_or_nil_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__create_tagged_immediate_value_or_nil(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__clasp_git_full_commit
 LCC_RETURN wrapped_core__clasp_git_full_commit_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__clasp_git_full_commit();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__lisp_implementation_id
 LCC_RETURN wrapped_core__lisp_implementation_id_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__lisp_implementation_id();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lisp_implementation_version
 LCC_RETURN wrapped_cl__lisp_implementation_version_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__lisp_implementation_version();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__lisp_implementation_type
 LCC_RETURN wrapped_cl__lisp_implementation_type_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::cl__lisp_implementation_type();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_number
 LCC_RETURN wrapped_core__next_number_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__next_number();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__interpreter_symbols
 LCC_RETURN wrapped_core__interpreter_symbols_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__interpreter_symbols();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__sleep
 LCC_RETURN wrapped_cl__sleep_Real_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Real_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__sleep(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__float_infinity_string
 LCC_RETURN wrapped_core__float_infinity_string_Float_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Float_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__float_infinity_string(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__build_single_dispatch_bytecode
 LCC_RETURN wrapped_core__build_single_dispatch_bytecode_List_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__build_single_dispatch_bytecode(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__verify_funcallable_instance_layout
 LCC_RETURN wrapped_core__verify_funcallable_instance_layout_size_tsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__verify_funcallable_instance_layout(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::clos__validate_dtree_bytecode_vm
 LCC_RETURN wrapped_clos__validate_dtree_bytecode_vm_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::clos__validate_dtree_bytecode_vm(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::clos__set_generic_function_compiled_dispatch_function
 LCC_RETURN wrapped_clos__set_generic_function_compiled_dispatch_function_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::clos__set_generic_function_compiled_dispatch_function(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::clos__generic_function_compiled_dispatch_function
 LCC_RETURN wrapped_clos__generic_function_compiled_dispatch_function_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::clos__generic_function_compiled_dispatch_function(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::clos__generic_function_interpreted_calls
 LCC_RETURN wrapped_clos__generic_function_interpreted_calls_FuncallableInstance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FuncallableInstance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::clos__generic_function_interpreted_calls(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::clos__setFuncallableInstanceFunction
 LCC_RETURN wrapped_clos__setFuncallableInstanceFunction_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::clos__setFuncallableInstanceFunction(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::clos__getFuncallableInstanceFunction
 LCC_RETURN wrapped_clos__getFuncallableInstanceFunction_FuncallableInstance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FuncallableInstance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Function_sp ret = core ::clos__getFuncallableInstanceFunction(a0._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__low_level_standard_generic_function_name
 LCC_RETURN wrapped_core__low_level_standard_generic_function_name_FuncallableInstance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FuncallableInstance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__low_level_standard_generic_function_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__allocate_raw_funcallable_instance
 LCC_RETURN wrapped_core__allocate_raw_funcallable_instance_Instance_spRack_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Rack_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::FuncallableInstance_sp ret = core ::core__allocate_raw_funcallable_instance(a0._v,a1._v);
     return translate::to_object<core::FuncallableInstance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__allocate_funcallable_standard_instance
 LCC_RETURN wrapped_core__allocate_funcallable_standard_instance_Instance_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__allocate_funcallable_standard_instance(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_rack_layout
 LCC_RETURN wrapped_core__verify_rack_layout_size_tsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__verify_rack_layout(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__verify_instance_layout
 LCC_RETURN wrapped_core__verify_instance_layout_size_tsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__verify_instance_layout(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::ext__class_unboundp
 LCC_RETURN wrapped_ext__class_unboundp_ClassHolder_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::ClassHolder_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::ext__class_unboundp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::ext__class_get
 LCC_RETURN wrapped_ext__class_get_ClassHolder_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::ClassHolder_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Instance_sp ret = core ::ext__class_get(a0._v);
     return translate::to_object<core::Instance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__has_creator
 LCC_RETURN wrapped_core__has_creator_Instance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__has_creator(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__class_creator
 LCC_RETURN wrapped_core__class_creator_Instance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__class_creator(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__name_of_class
 LCC_RETURN wrapped_core__name_of_class_Instance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__name_of_class(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rack_stamp
 LCC_RETURN wrapped_core__rack_stamp_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__rack_stamp(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__class_stamp_for_instances
 LCC_RETURN wrapped_core__class_stamp_for_instances_Instance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__class_stamp_for_instances(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__class_new_stamp
 LCC_RETURN wrapped_core__class_new_stamp_Instance_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__class_new_stamp(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::clos__direct_superclasses
 LCC_RETURN wrapped_clos__direct_superclasses_Instance_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::clos__direct_superclasses(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_cas
 LCC_RETURN wrapped_core__instance_cas_T_spT_spT_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__instance_cas(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_rack
 LCC_RETURN wrapped_core__instance_rack_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Rack_sp ret = core ::core__instance_rack(a0._v);
     return translate::to_object<core::Rack_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__allocate_raw_general_instance
 LCC_RETURN wrapped_core__allocate_raw_general_instance_Instance_spRack_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Rack_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Instance_sp ret = core ::core__allocate_raw_general_instance(a0._v,a1._v);
     return translate::to_object<core::Instance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__allocate_raw_instance
 LCC_RETURN wrapped_core__allocate_raw_instance_Instance_spRack_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Rack_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Instance_sp ret = core ::core__allocate_raw_instance(a0._v,a1._v);
     return translate::to_object<core::Instance_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__allocate_standard_instance
 LCC_RETURN wrapped_core__allocate_standard_instance_Instance_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__allocate_standard_instance(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__class_slot_sanity_check
 LCC_RETURN wrapped_core__class_slot_sanity_check_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = core ::core__class_slot_sanity_check();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__cas_rack
 LCC_RETURN wrapped_core__cas_rack_T_spT_spT_spRack_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Rack_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<size_t> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    core::T_sp ret = core ::core__cas_rack(a0._v,a1._v,a2._v,a3._v,a4._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__atomic_rack_write
 LCC_RETURN wrapped_core__atomic_rack_write_T_spT_spRack_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Rack_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core ::core__atomic_rack_write(a0._v,a1._v,a2._v,a3._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__atomic_rack_read
 LCC_RETURN wrapped_core__atomic_rack_read_T_spRack_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Rack_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__atomic_rack_read(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rack_ref
 LCC_RETURN wrapped_core__rack_ref_Rack_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Rack_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__rack_ref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rack_size
 LCC_RETURN wrapped_core__rack_size_Rack_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Rack_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__rack_size(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__rack_sig
 LCC_RETURN wrapped_core__rack_sig_Rack_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Rack_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__rack_sig(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__stamp_of_rack
 LCC_RETURN wrapped_core__stamp_of_rack_Rack_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Rack_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__stamp_of_rack(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_rack
 LCC_RETURN wrapped_core__make_rack_size_tT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__make_rack(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__call4
 LCC_RETURN wrapped_core__call4_intintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<int> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<int> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<int> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core ::core__call4(a0._v,a1._v,a2._v,a3._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__uninstall_sigchld
 LCC_RETURN wrapped_core__uninstall_sigchld_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__uninstall_sigchld();
     return Values0<core::T_O>();
    }
// Generating code for core::core__install_sigchld
 LCC_RETURN wrapped_core__install_sigchld_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__install_sigchld();
     return Values0<core::T_O>();
    }
// Generating code for core::core__decf_sigchld_count
 LCC_RETURN wrapped_core__decf_sigchld_count_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = core ::core__decf_sigchld_count();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__sigchld_count
 LCC_RETURN wrapped_core__sigchld_count_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    int ret = core ::core__sigchld_count();
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for core::core__handle_creator
 LCC_RETURN wrapped_core__handle_creator_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__handle_creator(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_builtin_class
 LCC_RETURN wrapped_core__make_builtin_class_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__make_builtin_class(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__declared_global_notinline_p
 LCC_RETURN wrapped_core__declared_global_notinline_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__declared_global_notinline_p(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__declared_global_inline_p
 LCC_RETURN wrapped_core__declared_global_inline_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__declared_global_inline_p(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__progv_env_function
 LCC_RETURN wrapped_core__progv_env_function_T_spList_spList_spFunction_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Function_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = core ::core__progv_env_function(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for core::core__progv_function
 LCC_RETURN wrapped_core__progv_function_List_spList_spFunction_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Function_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__progv_function(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__throw_function
 LCC_RETURN wrapped_core__throw_function_T_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__throw_function(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__catch_function
 LCC_RETURN wrapped_core__catch_function_T_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__catch_function(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__multiple_value_funcall
 LCC_RETURN wrapped_core__multiple_value_funcall_Function_spList_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::List_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__multiple_value_funcall(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__funwind_protect
 LCC_RETURN wrapped_core__funwind_protect_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__funwind_protect(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__call_with_variable_bound
 LCC_RETURN wrapped_core__call_with_variable_bound_Symbol_spT_spFunction_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Function_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__call_with_variable_bound(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__dladdr
 LCC_RETURN wrapped_core__dladdr_Pointer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__dladdr(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__call_dl_main_function
 LCC_RETURN wrapped_core__call_dl_main_function_Pointer_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__call_dl_main_function(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__dlsym
 LCC_RETURN wrapped_core__dlsym_T_spString_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__dlsym(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__dlopen
 LCC_RETURN wrapped_core__dlopen_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__dlopen(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__jit_register_symbol
 LCC_RETURN wrapped_core__jit_register_symbol_const_std__string_size_tvoid_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<const std::string&> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<void*> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core ::core__jit_register_symbol(a0._v,a1._v,a2._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__startup_image_pathname
 LCC_RETURN wrapped_core__startup_image_pathname_bool (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<bool> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__startup_image_pathname(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__mangle_name
 LCC_RETURN wrapped_core__mangle_name_Symbol_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__mangle_name(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__rdtsc
 LCC_RETURN wrapped_core__rdtsc_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    Fixnum ret = core ::core__rdtsc();
     return translate::to_object<Fixnum>::convert(ret).as_return_type();
    }
// Generating code for core::core__help_booting
 LCC_RETURN wrapped_core__help_booting_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core ::core__help_booting();
     return Values0<core::T_O>();
    }
// Generating code for core::core__trigger_dtrace_stop
 LCC_RETURN wrapped_core__trigger_dtrace_stop_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::T_sp ret = core ::core__trigger_dtrace_stop();
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__trigger_dtrace_start
 LCC_RETURN wrapped_core__trigger_dtrace_start_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::core__trigger_dtrace_start(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__xep_redirect_address
 LCC_RETURN wrapped_core__xep_redirect_address_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Pointer_sp ret = core ::core__xep_redirect_address(a0._v);
     return translate::to_object<core::Pointer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__literals_vref
 LCC_RETURN wrapped_core__literals_vref_Pointer_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Pointer_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__literals_vref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_jit_unique_counter
 LCC_RETURN wrapped_core__next_jit_unique_counter_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = core ::core__next_jit_unique_counter();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__next_jit_compile_counter
 LCC_RETURN wrapped_core__next_jit_compile_counter_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = core ::core__next_jit_compile_counter();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__update_max_jit_compile_counter
 LCC_RETURN wrapped_core__update_max_jit_compile_counter_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__update_max_jit_compile_counter(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__get_jit_compile_counter
 LCC_RETURN wrapped_core__get_jit_compile_counter_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    size_t ret = core ::core__get_jit_compile_counter();
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::Ephemeron_O::make
 LCC_RETURN wrapped_Ephemeron_O__make_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Ephemeron_sp ret = core ::Ephemeron_O::make(a0._v,a1._v);
     return translate::to_object<core::Ephemeron_sp>::convert(ret).as_return_type();
    }
// Generating code for core::WeakPointer_O::make
 LCC_RETURN wrapped_WeakPointer_O__make_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::WeakPointer_sp ret = core ::WeakPointer_O::make(a0._v);
     return translate::to_object<core::WeakPointer_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__sharp_equal_wrapper_p
 LCC_RETURN wrapped_core__sharp_equal_wrapper_p_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__sharp_equal_wrapper_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::make_sharp_equal_wrapper
 LCC_RETURN wrapped_make_sharp_equal_wrapper_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SharpEqualWrapper_sp ret = core ::make_sharp_equal_wrapper(a0._v);
     return translate::to_object<core::SharpEqualWrapper_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__run_creator
 LCC_RETURN wrapped_core__run_creator_Creator_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Creator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__run_creator(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_function_cell
 LCC_RETURN wrapped_core__make_function_cell_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::FunctionCell_sp ret = core ::core__make_function_cell(a0._v,a1._v,a2._v);
     return translate::to_object<core::FunctionCell_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__closure_slots_dump
 LCC_RETURN wrapped_core__closure_slots_dump_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__closure_slots_dump(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__closure_ref
 LCC_RETURN wrapped_core__closure_ref_Function_spsize_t (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<size_t> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__closure_ref(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__closure_length
 LCC_RETURN wrapped_core__closure_length_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__closure_length(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__closure_size
 LCC_RETURN wrapped_core__closure_size_size_t (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__closure_size(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_pointer_alist
 LCC_RETURN wrapped_core__function_pointer_alist_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__function_pointer_alist(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_closure
 LCC_RETURN wrapped_core__make_closure_SimpleFun_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleFun_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Closure_sp ret = core ::core__make_closure(a0._v,a1._v);
     return translate::to_object<core::Closure_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__verify_global_entry_point
 LCC_RETURN wrapped_core__verify_global_entry_point_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__verify_global_entry_point(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__verify_closure
 LCC_RETURN wrapped_core__verify_closure_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__verify_closure(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__function_docstring
 LCC_RETURN wrapped_core__function_docstring_Function_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__function_docstring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__dumpFunctionDescription
 LCC_RETURN wrapped_core__dumpFunctionDescription_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__dumpFunctionDescription(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__set_CoreFun_entry_point_indices
 LCC_RETURN wrapped_core__set_CoreFun_entry_point_indices_CoreFunGenerator_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::CoreFunGenerator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__set_CoreFun_entry_point_indices(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_SimpleCoreFun_entry_point_indices
 LCC_RETURN wrapped_core__set_SimpleCoreFun_entry_point_indices_SimpleCoreFunGenerator_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleCoreFunGenerator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__set_SimpleCoreFun_entry_point_indices(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__CoreFunGenerator_entry_point_indices
 LCC_RETURN wrapped_core__CoreFunGenerator_entry_point_indices_CoreFunGenerator_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::CoreFunGenerator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__CoreFunGenerator_entry_point_indices(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__SimpleCoreFunGenerator_entry_point_indices
 LCC_RETURN wrapped_core__SimpleCoreFunGenerator_entry_point_indices_SimpleCoreFunGenerator_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleCoreFunGenerator_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__SimpleCoreFunGenerator_entry_point_indices(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__SimpleFun_function_description
 LCC_RETURN wrapped_core__SimpleFun_function_description_SimpleFun_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleFun_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__SimpleFun_function_description(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_filepos
 LCC_RETURN wrapped_core__FunctionDescription_filepos_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__FunctionDescription_filepos(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_column
 LCC_RETURN wrapped_core__FunctionDescription_column_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__FunctionDescription_column(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_lineno
 LCC_RETURN wrapped_core__FunctionDescription_lineno_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    size_t ret = core ::core__FunctionDescription_lineno(a0._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_declares
 LCC_RETURN wrapped_core__FunctionDescription_declares_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__FunctionDescription_declares(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_docstring
 LCC_RETURN wrapped_core__FunctionDescription_docstring_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__FunctionDescription_docstring(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_lambdaList
 LCC_RETURN wrapped_core__FunctionDescription_lambdaList_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__FunctionDescription_lambdaList(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_functionName
 LCC_RETURN wrapped_core__FunctionDescription_functionName_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__FunctionDescription_functionName(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__FunctionDescription_sourcePathname
 LCC_RETURN wrapped_core__FunctionDescription_sourcePathname_FunctionDescription_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__FunctionDescription_sourcePathname(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__makeBytecodeSimpleFun
 LCC_RETURN wrapped_core__makeBytecodeSimpleFun_FunctionDescription_spBytecodeModule_spsize_tsize_tsize_tsize_tPointer_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::BytecodeModule_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<size_t> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<size_t> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<size_t> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::Pointer_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     
    core::BytecodeSimpleFun_sp ret = core ::core__makeBytecodeSimpleFun(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v);
     return translate::to_object<core::BytecodeSimpleFun_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__make_simple_core_fun
 LCC_RETURN wrapped_core__make_simple_core_fun_FunctionDescription_spPointer_spPointer_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Pointer_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleCoreFun_sp ret = core ::core__make_simple_core_fun(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleCoreFun_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__makeFunctionDescription
 LCC_RETURN wrapped_core__makeFunctionDescription_T_spT_spT_spT_spT_spintintint (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6,core::T_O* in7) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<int> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<int> a6 (core::T_sp((gc::Tagged)(in6)));
                     translate::from_object<int> a7 (core::T_sp((gc::Tagged)(in7)));
                     
    core::FunctionDescription_sp ret = core ::core__makeFunctionDescription(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v,a7._v);
     return translate::to_object<core::FunctionDescription_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__makeCoreFunGenerator
 LCC_RETURN wrapped_core__makeCoreFunGenerator_FunctionDescription_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::CoreFunGenerator_sp ret = core ::core__makeCoreFunGenerator(a0._v,a1._v);
     return translate::to_object<core::CoreFunGenerator_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__makeSimpleCoreFunGenerator
 LCC_RETURN wrapped_core__makeSimpleCoreFunGenerator_FunctionDescription_spT_spCoreFunGenerator_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::FunctionDescription_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::CoreFunGenerator_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::SimpleCoreFunGenerator_sp ret = core ::core__makeSimpleCoreFunGenerator(a0._v,a1._v,a2._v);
     return translate::to_object<core::SimpleCoreFunGenerator_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__simple_fun_ptrs
 LCC_RETURN wrapped_core__simple_fun_ptrs_SimpleFun_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::SimpleFun_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = core ::core__simple_fun_ptrs(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__aclasp_list_of_all_special_operators
 LCC_RETURN wrapped_core__aclasp_list_of_all_special_operators_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = core ::core__aclasp_list_of_all_special_operators();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__evaluate_verbosity
 LCC_RETURN wrapped_core__evaluate_verbosity_Fixnum_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Fixnum_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core ::core__evaluate_verbosity(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for core::ext__symbol_macro
 LCC_RETURN wrapped_ext__symbol_macro_Symbol_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::ext__symbol_macro(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__extract_lambda_name
 LCC_RETURN wrapped_core__extract_lambda_name_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__extract_lambda_name(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__extract_dump_module_from_declares
 LCC_RETURN wrapped_core__extract_dump_module_from_declares_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::core__extract_dump_module_from_declares(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__extract_lambda_name_from_declares
 LCC_RETURN wrapped_core__extract_lambda_name_from_declares_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__extract_lambda_name_from_declares(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__process_declarations
 LCC_RETURN wrapped_core__process_declarations_List_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__process_declarations(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__coerce_to_function
 LCC_RETURN wrapped_core__coerce_to_function_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Function_sp ret = core ::core__coerce_to_function(a0._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__funcall
 LCC_RETURN wrapped_cl__funcall_T_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__funcall(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__interpret
 LCC_RETURN wrapped_core__interpret_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__interpret(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__eval
 LCC_RETURN wrapped_cl__eval_T_sp (core::T_O* in0) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = core ::cl__eval(a0._v);
     return ret.as_return_type();
    }
// Generating code for core::core__apply4
 LCC_RETURN wrapped_core__apply4_Function_spT_spT_spT_spT_spT_spVaslist_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4,core::T_O* in5,core::T_O* in6) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     translate::from_object<core::T_sp> a5 (core::T_sp((gc::Tagged)(in5)));
                     translate::from_object<core::Vaslist_sp> a6 (core::T_sp((gc::Tagged)(in6)));
                     
    auto ret = core ::core__apply4(a0._v,a1._v,a2._v,a3._v,a4._v,a5._v,a6._v);
     return ret.as_return_type();
    }
// Generating code for core::core__apply3
 LCC_RETURN wrapped_core__apply3_Function_spT_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3,core::T_O* in4) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     translate::from_object<core::T_sp> a4 (core::T_sp((gc::Tagged)(in4)));
                     
    auto ret = core ::core__apply3(a0._v,a1._v,a2._v,a3._v,a4._v);
     return ret.as_return_type();
    }
// Generating code for core::core__apply2
 LCC_RETURN wrapped_core__apply2_Function_spT_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    auto ret = core ::core__apply2(a0._v,a1._v,a2._v,a3._v);
     return ret.as_return_type();
    }
// Generating code for core::core__apply1
 LCC_RETURN wrapped_core__apply1_Function_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    auto ret = core ::core__apply1(a0._v,a1._v,a2._v);
     return ret.as_return_type();
    }
// Generating code for core::core__trace_apply0
 LCC_RETURN wrapped_core__trace_apply0_Function_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__trace_apply0(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::core__apply0
 LCC_RETURN wrapped_core__apply0_Function_spT_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::core__apply0(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for core::cl__apply
 LCC_RETURN wrapped_cl__apply_T_spVaslist_sp (core::T_O* in0,core::T_O* in1) {
    
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Vaslist_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    auto ret = core ::cl__apply(a0._v,a1._v);
     return ret.as_return_type();
    }
// Generating code for mp::mp__fence
 LCC_RETURN wrapped_mp__fence_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__fence(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__check_pending_interrupts
 LCC_RETURN wrapped_mp__check_pending_interrupts_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    mp ::mp__check_pending_interrupts();
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__process_initial_special_bindings
 LCC_RETURN wrapped_mp__process_initial_special_bindings_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::List_sp ret = mp ::mp__process_initial_special_bindings(a0._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__copy_default_special_bindings
 LCC_RETURN wrapped_mp__copy_default_special_bindings_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = mp ::mp__copy_default_special_bindings();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__push_default_special_binding
 LCC_RETURN wrapped_mp__push_default_special_binding_core__Symbol_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Symbol_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    mp ::mp__push_default_special_binding(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__condition_variable_broadcast
 LCC_RETURN wrapped_mp__condition_variable_broadcast_ConditionVariable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::ConditionVariable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__condition_variable_broadcast(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__condition_variable_signal
 LCC_RETURN wrapped_mp__condition_variable_signal_ConditionVariable_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::ConditionVariable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__condition_variable_signal(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__condition_variable_timedwait
 LCC_RETURN wrapped_mp__condition_variable_timedwait_ConditionVariable_spMutex_spdouble (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::ConditionVariable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<mp::Mutex_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<double> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    bool ret = mp ::mp__condition_variable_timedwait(a0._v,a1._v,a2._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__condition_variable_wait
 LCC_RETURN wrapped_mp__condition_variable_wait_ConditionVariable_spMutex_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::ConditionVariable_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<mp::Mutex_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = mp ::mp__condition_variable_wait(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__make_condition_variable
 LCC_RETURN wrapped_mp__make_condition_variable_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__make_condition_variable(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__lock_count
 LCC_RETURN wrapped_mp__lock_count_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Fixnum_sp ret = mp ::mp__lock_count(a0._v);
     return translate::to_object<core::Fixnum_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__holding_lock_p
 LCC_RETURN wrapped_mp__holding_lock_p_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = mp ::mp__holding_lock_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__recursive_lock_p
 LCC_RETURN wrapped_mp__recursive_lock_p_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = mp ::mp__recursive_lock_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__giveup_lock
 LCC_RETURN wrapped_mp__giveup_lock_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__giveup_lock(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__get_lock
 LCC_RETURN wrapped_mp__get_lock_core__T_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = mp ::mp__get_lock(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__mutex_name
 LCC_RETURN wrapped_mp__mutex_name_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__mutex_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__PERCENTabort_process
 LCC_RETURN wrapped_mp__PERCENTabort_process_core__T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__PERCENTabort_process(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__exit_process
 LCC_RETURN wrapped_mp__exit_process_core__List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__exit_process(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__enqueue_interrupt
 LCC_RETURN wrapped_mp__enqueue_interrupt_Process_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    mp ::mp__enqueue_interrupt(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__process_preset
 LCC_RETURN wrapped_mp__process_preset_Process_spcore__T_spcore__T_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = mp ::mp__process_preset(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_join
 LCC_RETURN wrapped_mp__process_join_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    auto ret = mp ::mp__process_join(a0._v);
     return ret.as_return_type();
    }
// Generating code for mp::mp__process_yield
 LCC_RETURN wrapped_mp__process_yield_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    mp ::mp__process_yield();
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__process_resume
 LCC_RETURN wrapped_mp__process_resume_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__process_resume(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__suspend_loop
 LCC_RETURN wrapped_mp__suspend_loop_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    mp ::mp__suspend_loop();
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__process_active_p
 LCC_RETURN wrapped_mp__process_active_p_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = mp ::mp__process_active_p(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__thread_id
 LCC_RETURN wrapped_mp__thread_id_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__thread_id(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__set_process_name
 LCC_RETURN wrapped_mp__set_process_name_Process_spcore__T_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    mp ::mp__set_process_name(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__process_name
 LCC_RETURN wrapped_mp__process_name_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__process_name(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__all_processes
 LCC_RETURN wrapped_mp__all_processes_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    core::List_sp ret = mp ::mp__all_processes();
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_run_function
 LCC_RETURN wrapped_mp__process_run_function_core__T_spcore__T_spcore__List_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::List_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    mp::Process_sp ret = mp ::mp__process_run_function(a0._v,a1._v,a2._v);
     return translate::to_object<mp::Process_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_start
 LCC_RETURN wrapped_mp__process_start_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__process_start(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__lock_owner
 LCC_RETURN wrapped_mp__lock_owner_Mutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Mutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__lock_owner(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_waiting_on
 LCC_RETURN wrapped_mp__process_waiting_on_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = mp ::mp__process_waiting_on(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_phase
 LCC_RETURN wrapped_mp__process_phase_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    int ret = mp ::mp__process_phase(a0._v);
     return translate::to_object<int>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__process_phase_string
 LCC_RETURN wrapped_mp__process_phase_string_Process_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::Process_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::SimpleBaseString_sp ret = mp ::mp__process_phase_string(a0._v);
     return translate::to_object<core::SimpleBaseString_sp>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__shared_unlock
 LCC_RETURN wrapped_mp__shared_unlock_SharedMutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::SharedMutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__shared_unlock(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__shared_lock
 LCC_RETURN wrapped_mp__shared_lock_SharedMutex_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::SharedMutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    mp ::mp__shared_lock(a0._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__write_unlock
 LCC_RETURN wrapped_mp__write_unlock_SharedMutex_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::SharedMutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    mp ::mp__write_unlock(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__write_try_lock
 LCC_RETURN wrapped_mp__write_try_lock_SharedMutex_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::SharedMutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = mp ::mp__write_try_lock(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for mp::mp__write_lock
 LCC_RETURN wrapped_mp__write_lock_SharedMutex_spbool (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<mp::SharedMutex_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<bool> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    mp ::mp__write_lock(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for mp::mp__current_process
 LCC_RETURN wrapped_mp__current_process_ () {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    
    mp::Process_sp ret = mp ::mp__current_process();
     return translate::to_object<mp::Process_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__listp
 LCC_RETURN wrapped_cl__listp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__listp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__characterp
 LCC_RETURN wrapped_cl__characterp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__characterp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__consp
 LCC_RETURN wrapped_cl__consp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__consp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__atom
 LCC_RETURN wrapped_cl__atom_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__atom(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__endp
 LCC_RETURN wrapped_cl__endp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__endp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__fixnump
 LCC_RETURN wrapped_core__fixnump_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::core__fixnump(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__symbolp
 LCC_RETURN wrapped_cl__symbolp_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    bool ret = core ::cl__symbolp(a0._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::clasp_reciprocal
 LCC_RETURN wrapped_clasp_reciprocal_Number_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::clasp_reciprocal(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::clasp_negate
 LCC_RETURN wrapped_clasp_negate_Number_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Number_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::Number_sp ret = core ::clasp_negate(a0._v);
     return translate::to_object<core::Number_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__equal
 LCC_RETURN wrapped_cl__equal_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__equal(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::core__eql_underlying
 LCC_RETURN wrapped_core__eql_underlying_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::core__eql_underlying(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__eql
 LCC_RETURN wrapped_cl__eql_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__eql(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::cl__eq
 LCC_RETURN wrapped_cl__eq_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::cl__eq(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::oTenth
 LCC_RETURN wrapped_oTenth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oTenth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oNinth
 LCC_RETURN wrapped_oNinth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oNinth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oEighth
 LCC_RETURN wrapped_oEighth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oEighth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oSeventh
 LCC_RETURN wrapped_oSeventh_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oSeventh(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oSixth
 LCC_RETURN wrapped_oSixth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oSixth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oFifth
 LCC_RETURN wrapped_oFifth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oFifth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oFourth
 LCC_RETURN wrapped_oFourth_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oFourth(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oThird
 LCC_RETURN wrapped_oThird_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oThird(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oSecond
 LCC_RETURN wrapped_oSecond_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oSecond(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oFirst
 LCC_RETURN wrapped_oFirst_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oFirst(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCddddr
 LCC_RETURN wrapped_oCddddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCddddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCddadr
 LCC_RETURN wrapped_oCddadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCddadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdaddr
 LCC_RETURN wrapped_oCdaddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdaddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdaadr
 LCC_RETURN wrapped_oCdaadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdaadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCadddr
 LCC_RETURN wrapped_oCadddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCadddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCadadr
 LCC_RETURN wrapped_oCadadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCadadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaaddr
 LCC_RETURN wrapped_oCaaddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaaddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaaadr
 LCC_RETURN wrapped_oCaaadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaaadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdddar
 LCC_RETURN wrapped_oCdddar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdddar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCddaar
 LCC_RETURN wrapped_oCddaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCddaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdadar
 LCC_RETURN wrapped_oCdadar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdadar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdaaar
 LCC_RETURN wrapped_oCdaaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdaaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaddar
 LCC_RETURN wrapped_oCaddar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaddar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCadaar
 LCC_RETURN wrapped_oCadaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCadaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaadar
 LCC_RETURN wrapped_oCaadar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaadar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaaaar
 LCC_RETURN wrapped_oCaaaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaaaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdddr
 LCC_RETURN wrapped_oCdddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCddar
 LCC_RETURN wrapped_oCddar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCddar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdadr
 LCC_RETURN wrapped_oCdadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdaar
 LCC_RETURN wrapped_oCdaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaddr
 LCC_RETURN wrapped_oCaddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCadar
 LCC_RETURN wrapped_oCadar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCadar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaadr
 LCC_RETURN wrapped_oCaadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaaar
 LCC_RETURN wrapped_oCaaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCddr
 LCC_RETURN wrapped_oCddr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCddr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdar
 LCC_RETURN wrapped_oCdar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCadr
 LCC_RETURN wrapped_oCadr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCadr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCaar
 LCC_RETURN wrapped_oCaar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCaar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__rest
 LCC_RETURN wrapped_cl__rest_List_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::cl__rest(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCdr
 LCC_RETURN wrapped_oCdr_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCdr(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::oCar
 LCC_RETURN wrapped_oCar_T_sp (core::T_O* in0) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     
    core::T_sp ret = core ::oCar(a0._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::setf_jit_lookup_t
 LCC_RETURN wrapped_setf_jit_lookup_t_core__T_spJITDylib_spconst_std__string_ (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::JITDylib_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<const std::string&> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = llvmo ::setf_jit_lookup_t(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for llvmo::code_literal_set
 LCC_RETURN wrapped_code_literal_set_core__T_spObjectFile_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<llvmo::ObjectFile_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = llvmo ::code_literal_set(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_elt
 LCC_RETURN wrapped_core__setf_elt_T_spT_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__setf_elt(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__put_sysprop
 LCC_RETURN wrapped_core__put_sysprop_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__put_sysprop(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_set
 LCC_RETURN wrapped_core__instance_set_T_spT_spint (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<int> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__instance_set(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__variable_cell_set_value
 LCC_RETURN wrapped_core__variable_cell_set_value_T_spVariableCell_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::VariableCell_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__variable_cell_set_value(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__putprop
 LCC_RETURN wrapped_core__putprop_T_spSymbol_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__putprop(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_symbol_plist
 LCC_RETURN wrapped_core__set_symbol_plist_List_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::List_sp ret = core ::core__set_symbol_plist(a0._v,a1._v);
     return translate::to_object<core::List_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__schar_set
 LCC_RETURN wrapped_core__schar_set_Character_spString_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Character_sp ret = core ::core__schar_set(a0._v,a1._v,a2._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__char_set
 LCC_RETURN wrapped_core__char_set_Character_spString_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Character_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::Character_sp ret = core ::core__char_set(a0._v,a1._v,a2._v);
     return translate::to_object<core::Character_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_svref
 LCC_RETURN wrapped_core__setf_svref_T_spSimpleVector_spcl_index (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SimpleVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<cl_index> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__setf_svref(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__atomic_aset
 LCC_RETURN wrapped_core__atomic_aset_T_spT_spArray_spVaslist_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Array_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::Vaslist_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::core__atomic_aset(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__aset
 LCC_RETURN wrapped_core__aset_T_spArray_spVaslist_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Array_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::Vaslist_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__aset(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__fillPointerSet
 LCC_RETURN wrapped_core__fillPointerSet_size_tArray_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<size_t> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Array_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    size_t ret = core ::core__fillPointerSet(a0._v,a1._v);
     return translate::to_object<size_t>::convert(ret).as_return_type();
    }
// Generating code for core::core__vset
 LCC_RETURN wrapped_core__vset_T_spAbstractSimpleVector_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::AbstractSimpleVector_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__vset(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rowMajorAset
 LCC_RETURN wrapped_core__rowMajorAset_T_spArray_spgc__Fixnum (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Array_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<gc::Fixnum> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__rowMajorAset(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::set_package_documentation
 LCC_RETURN wrapped_set_package_documentation_T_spPackage_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Package_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::set_package_documentation(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::set_package_local_nicknames_internal
 LCC_RETURN wrapped_set_package_local_nicknames_internal_T_spPackage_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Package_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::set_package_local_nicknames_internal(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::cl__setf_logical_pathname_translations
 LCC_RETURN wrapped_cl__setf_logical_pathname_translations_List_spString_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::List_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::String_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__setf_logical_pathname_translations(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__readtable_case_set
 LCC_RETURN wrapped_core__readtable_case_set_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__readtable_case_set(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set_stream_external_format
 LCC_RETURN wrapped_cl__set_stream_external_format_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__set_stream_external_format(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::cl__set_stream_element_type
 LCC_RETURN wrapped_cl__set_stream_element_type_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::cl__set_stream_element_type(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_gethash
 LCC_RETURN wrapped_setf_gethash_T_spT_spHashTable_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2,core::T_O* in3) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::HashTable_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     translate::from_object<core::T_sp> a3 (core::T_sp((gc::Tagged)(in3)));
                     
    core::T_sp ret = core ::setf_gethash(a0._v,a1._v,a2._v,a3._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__set_variable_source_info
 LCC_RETURN wrapped_core__set_variable_source_info_T_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__set_variable_source_info(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_symbol_function
 LCC_RETURN wrapped_setf_symbol_function_Function_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::setf_symbol_function(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_fdefinition
 LCC_RETURN wrapped_setf_fdefinition_Function_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::setf_fdefinition(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_symbol_constantp
 LCC_RETURN wrapped_setf_symbol_constantp_T_spSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::setf_symbol_constantp(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_symbol_specialp
 LCC_RETURN wrapped_setf_symbol_specialp_boolSymbol_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<bool> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    bool ret = core ::setf_symbol_specialp(a0._v,a1._v);
     return translate::to_object<bool>::convert(ret).as_return_type();
    }
// Generating code for core::setf_macro_function
 LCC_RETURN wrapped_setf_macro_function_Function_spSymbol_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Symbol_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::setf_macro_function(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_function_type
 LCC_RETURN wrapped_core__setf_function_type_T_spT_spT_sp (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<core::T_sp> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__setf_function_type(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__instance_rack_set
 LCC_RETURN wrapped_core__instance_rack_set_Rack_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Rack_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core ::core__instance_rack_set(a0._v,a1._v);
     return Values0<core::T_O>();
    }
// Generating code for core::core__instance_class_set
 LCC_RETURN wrapped_core__instance_class_set_Instance_spT_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Instance_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::T_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__instance_class_set(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__rack_set
 LCC_RETURN wrapped_core__rack_set_T_spRack_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Rack_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__rack_set(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__literals_vset
 LCC_RETURN wrapped_core__literals_vset_T_spPointer_spsize_t (core::T_O* in0,core::T_O* in1,core::T_O* in2) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Pointer_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     translate::from_object<size_t> a2 (core::T_sp((gc::Tagged)(in2)));
                     
    core::T_sp ret = core ::core__literals_vset(a0._v,a1._v,a2._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__setf_sharp_equal_wrapper_value
 LCC_RETURN wrapped_core__setf_sharp_equal_wrapper_value_T_spSharpEqualWrapper_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::SharpEqualWrapper_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::core__setf_sharp_equal_wrapper_value(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
// Generating code for core::core__function_cell_set_function
 LCC_RETURN wrapped_core__function_cell_set_function_Function_spFunctionCell_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::Function_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::FunctionCell_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::Function_sp ret = core ::core__function_cell_set_function(a0._v,a1._v);
     return translate::to_object<core::Function_sp>::convert(ret).as_return_type();
    }
// Generating code for core::setf_function_docstring
 LCC_RETURN wrapped_setf_function_docstring_T_spFunction_sp (core::T_O* in0,core::T_O* in1) {
    gctools::StackAllocate<core::UnknownDynEnv_O> sa_ude;
                 gctools::StackAllocate<core::Cons_O> sa_ec(sa_ude.asSmartPtr(), my_thread->dynEnvStackGet());
                 core::DynEnvPusher dep(my_thread, sa_ec.asSmartPtr());
    translate::from_object<core::T_sp> a0 (core::T_sp((gc::Tagged)(in0)));
                     translate::from_object<core::Function_sp> a1 (core::T_sp((gc::Tagged)(in1)));
                     
    core::T_sp ret = core ::setf_function_docstring(a0._v,a1._v);
     return translate::to_object<core::T_sp>::convert(ret).as_return_type();
    }
